Amiga Games: Greatest Hits 1996/Amiga Games: Greatest Hits 1996.iso/spiele/demoversionen/doopsi/docs/doopsi_ita.guide

Text File | 1996-07-02 | 108.1 KB | 2,661 lines

*************
Introduzione.
*************

Il nome del gioco.

Doopsi-GS significa:  Dinamical Object Oriented Programming System
Interface - Game System.  Abbiamo dato questo nome al nostro programma per
vari motivi:  ci ricorda Boopsi, ovvero l'interfaccia Intuition Orientata
agli Oggetti del nostro beneamato Amiga; è un programma Orientato agli
Oggetti nel senso tecnico del termine, cioè per quanto riguarda la sua
struttra interna (qualche notizia di questa struttura è riportata nell'
Appendice C); è un'Interfaccia di Programmazione poiché semplifica il
compito di programmazione rendendolo completamente automatico e veloce.


Questo Sistema di Programmazione è molto diverso dagli altri prodotti
dedicati al medesimo scopo poiché è estemamente semplice da usare, anche
per coloro che avessero poca abilità di programmazione:  l'utente disegna
tutta la grafica e fornisce tutti i suoni e le musiche di cui necessita e
poi il nostro programma mette tutto assieme.  L'idea che giace sotto il
funzionamento di questo programma è immediata:  voi definite prima di tutto
le scene, poi ponete alcuni oggetti in esse e, infine, specificate come
ciascun oggetto deve reagire quando il giocatore agisce su di esso (questa
è l'unica parte di programmazione che dovete affrontare).  Per essere
sincero vi sono altre parti del lavoro che non ho incluso nella descrizione
precedente, ma le imparerete man mano che verrete maggiormente coinvolti in
Doopsi:  per esempio, uno dei compiti che dovrete affrontare è quello di
costruire il percorso lungo il quale l'Omino cammina (l'Omino con la
maiuscola è il protagonista dell'avventura), oppure un'altro compito è
quello di scrivere i dialoghi fra l'Omino e qualche altro oggetto, e così
via.


Queste sono alcune caratteristiche di Doopsi:

- sensibile al sistema operativo (funziona sotto V37+).

- completamente localizzabile (usa la nostra "locator.library" per cambiare
    linguaggio, ma nelle future versioni lo adatteremo alla standard
    "locale.library" se riusciremo a farla funzionare sotto V37).

- compatibile AGA.

- l'Editor è completamente system friendly.

- gestisce bitmap più grosse dell'area di schermo (con autoscroll).

- permette di suonare moduli e campionamenti durante il gioco.

- completamente personalizzabile (ad es.: potete anche ridisegnare la
   pulsantiera del Player).


Doopsi è costituito da due programmi indipendenti:  l'Editor ed il Player.
Come i loro nomi possono suggerire, l'Editor è quello che costruisce
l'avventura, mentre il Player sfrutta i dati prodotti dall'Editor per farvi
giocare.  E' come se l'Editor generasse una specie di programma ed il
Player fosse l'interprete di tale programma:  se si verifica un errore
durante l'esecuzione il Player visualizza un messaggio di errore e, se può,
continua l'elaborazione del gioco, come un qualsiasi interprete di un
qualunque linguaggio farebbe (i linguaggi reali però non possono continuare
dopo un errore, ma noi siamo migliori e possiamo!).


Il manuale ha la seguente struttura:  questa sezione introduttiva è seguita
dalla descrizione della procedura di installazione.  Poi iniziamo con la
Finestra Principale dell'Editor Doopsi, contenente la descrizione di tutti
i (numerosi) bottoni che appaiono (non vi spaventate, imparerete presto ad
usarli).  Dopo la Finestra Principale vi sono tre sezioni dedicate ai tre
editor relativi alla costruzione della scena:  il Path Editor, lo Spot
Editor e lo Screen Attributes Editor.  Seguono le sezioni dedicate agli
oggetti e che descrivono rispettivamente:  l'Object Attributes Editor, il
Doopsi Coder e l'Anim Editor.  Rimangono solo due editor, e questi
costituiscono il soggetto delle sezioni seguenti:  il Dialog Editor e
l'Editor di Preferenze.  La parte principale del manuale è finita ma
abbiamo anche tre appendici:  la prima descrive tutte le istruzioni del
Linguaggio Doopsi (il Linguaggio Doopsi è usato nel Doopsi Coder per
programmare gli oggetti); la seconda descrive il profilo della console
inclusa nel pacchetto (la console è la parte bassa del gioco, quella con le
azioni); e la terza contiene alcuni dettagli tecnici a proposito della
struttura interna degli Oggetti Doopsi (questa non è necessaria ad una
prima lettura, ma è inclusa per utenti più esperti (o più curiosi)).  Anche
il Player abbisogna di un minimo di spiegazione, e lo descriviamo
nell'ultima sezione del manuale, situata dopo tutte le appendici.  Questo è
tutto, gente.


Una osservazione:  probabilmente questo manuale è un po' caotico, nel senso
che le informazioni utili sono sparpagliate ovunque e nascoste fra mucchi
di rifiuti.  Questo significa che dovete essere più attenti nel leggere, in
modo da non saltare alcune nozioni interessanti (e vitali).  Siamo
spiacenti, ma questa è solo la prima versione e continueremo a sistemarla
in modo da migliorarla.  Dunque ogni commento è gradito, e terremo anche
una lista di FAQ nelle nostre pagine Web.


---------------------------------------------------------------------------


***************************************************
Gli autori (la parte più interessante del manuale):
***************************************************

questa è la situazione fino al 27 - 6 - 1996 (data del primo upload):

Andrea si è appena laureato in Fisica all'Università di Milano, e sta
studiando per entrare in un corso di Dottorato.

Fabio sta lavorando come capo progetto presso la DeAgostini Multimedia
di Milano. Ama gli Amiga, i dolci, le ragazze, divertirsi, programmare a
oggetti e DOOPSI ;)


I nostri indirizzi sono:

      Fabio Rotondo                    Andrea Galimberti
      c.so Vercelli, 9                 via Villoresi, 87
      28100 Novara                     20029 Turbigo (Mi)
      Italia                           Italia
      E-Mail: [e-mail]

      Phone: (ITA) - (0)321 - 459676   Phone: (ITA) - (0)331 - 871009


Le pagine Web sono:

      http://www.intercom.it/~fsoft/doopsi.html    -> DOOPSI Home Page!!!
      http://www.intercom.it/~fsoft                -> Fabio Soft Home Page

DOOPSI Mailing list:

      per iscriversi mandare una mail a:

         [e-mail]

      con:

         SUBSCRIBE DOOPSI your_name@your_email.addr

      nel corpo del messaggio.


---------------------------------------------------------------------------


***************
Ringraziamenti:
***************

Mik and Gio of ClassX:   per alcune utili routine. Per il loro supporto,
                         per le loro idee, per essere loro.

Giorgio Fornara:     per la grandiosa grafica della Demo che non è inclusa
                     in questo pacchetto, ma che apparirà il più presto
                     possibile. Ha anche disegnato il logo di Doopsi che
                     appare sullo schermo dell'Editor.

Andrea Rotondo:      per la grafica del Tutorial.

Stefano Clemente:    per il beta-testing.

Lele e Paolo di Intercom: per aver creato la DOOPSI - Mailing list.

Max Galimberti:      per aver controllato questo manuale.


*******
Saluti:
*******

da Andrea a Laura: per avermi sopportato fino ad ora.

da Fabio alla sua mamma (e anche al suo papà).


---------------------------------------------------------------------------


********************************
ACCORDO DI LICENZA PER DOOPSI-GS
********************************

I. DIRITTI E RESTRIZIONI DI QUESTA LICENZA

Fabio Rotondo e Andrea Galimberti (gli "autori") vi assicurano
il diritto non-esclusivo, non-assegnabile di usare il software
DOOPSI-GS incluso come eseguibile ("DOOPSI") su di un massimo di 1
computer system alla volta. Non potete effettuare reverse engeneering,
decompilare, o dissassemblare DOOPSI, non rispettare queste restrizioni
e' espressamente proibito dalle leggi vigenti. Non potete prestare o
affittare DOOPSI, o trasferire DOOPSI in altro modo e il materiale
scritto che lo accompagna.
Tutti i diritti non espressamente citati sono riservati dagli autori.

II. NESSUNA GARANZIA

DOOPSI e il materiale scritto che lo accompagna e' fornito "cosi' com'e'",
senza alcuna garanzia di alcun tipo. Per quanto consentito dalla legge,
gli autori scaricano tutte le responsabilita', sia implicite che
esplicite, comprese implicite garanzie di vendibilita', utilita'
per un compito particolare e di non violazione. Gli interi rischi
derivanti dall'uso o dal comportamento di DOOPSI e del materiale
scritto che l'accompagna rimangono a voi.

III. NESSUN OBBLIGO PER DANNI CONSEGUENTI L'USO

Per quanto consentito dalla legge: in alcun caso gli autori o i
loro collaboratori potranno essere accusati per qualsiasi danno
(compresi, senza limitazione, danni per profitti di affari,
interruzione degli affari, perdita di dati commerciali, o qualsiasi
possibilita' di perdita monetaria) derivante dall'uso o dalla
inadeguatezza di usare DOOPSI, persino se gli autori sono stati
avvisati della possibilita' di tali danni. Dal momento che
alcuni stati/giurisdizioni non permettono l'esclusione o la limitazione
di garanzia per danni consequenziali o incidentali, questa limitazione
potrebbe non riguardarvi.

IV. COPIA E DISTRIBUZIONE

Siete autorizzati a distribuire e copiare questo documento con
tutto il resto dell'archivio, solo se il programma e' una versione
"SHAREWARE" o "SPECIAL EDITION". La "SPECIAL EDITION" non puo' essere
distribuita su Aminet o in qualsiasi BBS e non puo' comparire in
alcuna rivista senza il permesso scritto degli autori.
Voi potete, e siete invitati a farlo, copiare e distribuire la versione
originale di DOOPSI SHAREWARE VERSION, ma NON DOVETE COPIARE in qualsiasi
forma la DOOPSI REGISTERED VERSION (versione registrata), eccezion fatta
per l'utilizzo personale.

V. VARIE

Se avete acquistato questo prodotto negli Stati Uniti, questo Accordo e'
soggetto alle leggi dello Stato di Washington. Se avete acquistato
questo prodotto fuori dagli Stati Uniti, verranno applicate le leggi
locali. Se una qualsiasi parte esterna si arroca dei diritti derivanti
dal presente Accordo, la parte prevalente potrebbe essere autorizzata a
richiedere somme di denaro per il risarcimento per l'offesa, i costi e le
spese.


---------------------------------------------------------------------------


**************
Installazione.
**************

Vi è uno script per l'Installer che svolge questo compito, ma per coloro
che desiderassero farlo a mano descriveremo cosa deve essere installato e
dove.  (A proposito:  per usare lo script dovete possedere l'Installer e
l'utility Lha.)


I tre archivi hanno già la struttura finale delle directory.  Dovete prima
estrarre l'archivio Programs.lha; quest'ultimo crea due directory:  una
contiene l'Editor e l'altra contiene il Player.  Vi è anche una terza
directory in cui potete trovare due librerie:  la "locator.library" e la
famosa "reqtools.library"; dovete copiare queste librerie nella vostra
directory Libs:.  L'ultimo passo consiste nel fare la seguente
assegnazione:  Assign Doopsi: alla directory dell'Editor.

La lingua di default è l'inglese, ma sono forniti anche i cataloghi per
installare l'italiano:  dovete solo estrarre l'archivio Catalogs.lha nella
stessa directory dove avete messo il cassetto dell'Editor (non NEL cassetto
dell'Editor, ma VICINO a tale cassetto).  Questo crea una directory
Catalogs nel cassetto dell'Editor ed aggiunge anche il file
"player.catalog" nella directory "Editor/Data".

Poi dovete estrarre l'archivio Tutorial.lha nella stessa directory dove
avete messo il cassetto dell'Editor (non NEL cassetto dell'Editor, ma
VICINO a tale cassetto):  questo crea una directory Tutorial nel cassetto
dell'Editor, dove potete trovare un po' di grafica per iniziare
immediatamente.

Per riassumere:  gli archivi son stati costruiti in modo tale che, se li
estraete tutti nella medesima directory, il loro contenuto finirà nei posti
giusti.

La struttura risultante delle directory è:

      Editor
      |
      +---Catalogs
      |
      +---Docs
      |
      +---palettes
      |
      +---Data
      |
      `---Tutorial
          |
          +---Objects
          |
          +---Berny
          |
          +---Scenes
          |
          `---Sounds

      Player


L'Editor Deve trovare nella propria directory il file "doopsi.dat".  La
directory Catalogs serve solo se volete usare un linguaggio diverso
dall'inglese (per il momento sono forniti solo i cataloghi italiani):
copiate in tale cassetto solo i cataloghi del vostro linguaggio preferito e
lasciate fuori gli altri.

Il Player Deve trovare nella directory che scegliete mediante l'Editor (si
veda la sezione di questo manuale dedicata alla finestra di Preferenze) i
seguenti file:  "player.dat" e "panel.iff".  Il file "panel.iff" è la
console che potete cambiare (vedere l'Appendice B).  Il file
"player.catalog" è necessario solo se volete usare un linguaggio diverso
dall'inglese, altrimenti potete buttarlo via.

I sorgenti dei cataloghi verranno forniti (se si desidera), insieme agli
eseguibili per crearli, in un pacchetto a parte.


NOTA IMPORTANTE:  L'Editor ha bisogno dell'assegnamento Doopsi:, ma il
Player è stato costruito in modo da essere completamente rilocabile (non
necessita di assegnamenti).  Quando caricate il Player da una Shell dovete
semplicemente far diventare la directory del Player quella corrente e poi
chiamare il programma:  il Player cercherà quindi la directory che avete
selezionato mediante l'Editor (quella di default è la directory "Data"
creata dagli archivi), dove Deve trovare i file "player.dat" e "panel.iff".

La linea di comando per caricare il Player è:  Player nome_file_Doopsi.  Se
dimenticate di fornire il nome del file, il Player apre un file requester e
vi chiede di selezionare un file.


---------------------------------------------------------------------------


***********************
La finestra principale.
***********************

La storia inizia da qui.

Prima di tutto, descriviamo i contenuti della finestra.  La parte più alta
è divisa in due sezioni:  quella di sinistra riguarda le scene, mentre
quella di destra è dedicata agli oggetti.  Poi segue una riga contenente
alcuni editor misti e, infine, la riga finale contiene dei gadget dedicati
al caricamento e salvataggio di tutto il vostro lavoro.


Iniziamo con la sezione delle scene.  Per creare una nuova scena dovete
premere il bottone "Nuovo" e, dopo aver selezionato l'immagine di sfondo
mediante il file requester, vi si chiede di inserire il nome della scena:
questo nome è l'identificatore che Doopsi usa per indirizzare la scena,
quindi siete invitati a non chiamare due scene con il medesimo nome.  Dopo
che lo sfondo è stato visualizzato siete pronti per lavorare su questa
scena (per es.:  posizionando degli oggetti su di essa).  Per selezionare
la scena su cui lavorare dovete usare il gadget "Lista":  cliccate sul nome
desiderato nella lista e poi sul bottone "Ok".  Il gadget "Uccidi" serve
per rimuovere la scena corrente.

Quando premete il bottone "Salva" l'editor vi chiede se volete salvare solo
la scena corrente o tutte le scene create fino ad ora.  Con il gadget
"Carica" potete caricare entrambi i tipi di file:  l'Editor riconosce
automaticamente se il file che avete selezionato contiene una o più scene.
Se gli oggetti agganciati alla scena che volete caricare sono già stati
caricati, allora l'editor può posizionarli immediatamente sulla scena
stessa; se invece caricate gli oggetti dopo che la scena è stata caricata,
allora dovete posizionare tali oggetti a mano, cliccando sul gadget "R"
("R" sta per "ripristina").  Il gadget "Carica" può anche estrarre le
informazioni delle scene da un file salvato con il gadget "Salva Tutto"
posizionato nella fila inferiore della finestra (vedi la descrizione di
tale gadget per informazioni maggiori).

I gadget rimanenti aprono altri editor, e si rimanda alle sezioni del
manuale dedicate a tali editor per informazioni più specifiche.  Il gadget
"Attrs" serve per attivare l'editor degli Attributi delle Scene, dove
potete cambiare alcune caratteristiche della vostra scena; il bottone "Spot
editor" invoca lo Spot Editor per posizionare alcuni Spot sulla scena; il
gadget "Path editor" accede al Path Editor usato per creare il percorso su
cui il vostro Omino dovrebbe camminare.


Ora sapete come creare una nuova scena e siete pronti per posizionarvi
degli oggetti, quindi diamo uno sguardo alla sezione degli oggetti.  Il
gadget "Nuovo" crea un nuovo oggetto ed apre l'editor degli Attributi degli
Oggetti per permettere all'utente di modificare tale oggetto (si veda la
sezione dedicata all'editor degli Attributi per gli Oggetti).  Il gadget
"Lista" visualizza la lista di tutti gli oggetti creati fino ad ora:  per
lavorare su un oggetto dovete renderlo l'oggetto corrente selezionando il
suo nome dalla lista.  Il bottone "Uccidi" rimuove l'oggetto corrente.

Il gadget "Salva" chiede se volete salvare solo l'oggetto corrente o tutti
gli oggetti creati.  Il bottone "Carica" riconosce se il file che avete
selezionato contiene uno o più oggetti e gli aggiunge alla lista.  Questo
bottone può anche estrarre i dati degli oggetti da un file salvato con il
gadget "Salva Tutto".

Il gadget "Attrib" apre l'editor degli Attributi degli Oggetti (quello a
cui accedete automaticamente quando create un nuovo oggetto); il bottone
"Doopsi code" invoca il Doopsi Coder utilizzato per specificare come si
deve comportare il Player quando l'utente agisce su un oggetto; il gadget
"Anim editor" apre l'Anim Editor che vi permette di convertire un oggetto
in un AnimObject costruendo un'animazione a partire dalle sue immagini.

Potete muovere tutti gli oggetti che avete creato e posizionato sulla scena
(utilizzando l'Object Attributes editor) cliccando su di essi con il
bottone sinistro del mouse e (tenendo premuto questo bottone) trascinandoli
all'interno della scena. Cliccando su di essi con il bottone destro del
mouse rendete oggetto corrente l'oggetto selezionato ed invocate l'Object
Attributes editor.


La sezione successiva contiene tre bottoni:  il bottone "Prefs" accede
all'editor delle Preferenze dove potete modificare ad esempio alcuni nomi
che il Player usa come default, o i vostri path preferiti, e così via; il
"Dialog Editor" invoca il Dialog Editor utilizzato per creare dialoghi fra
il vostro Omino e un altro personaggio della vostra storia; il gadget
"Info" vi dice quanti oggetti e scene avete creato fino ad ora e la
quantità di memoria disponibile.  Infine il bottone "Prova Gioco" invoca il
Player affinché possiate provare immediatamente la vostra avventura:
l'Editor cerca il Player nella directory indicatagli mediante l'apposito
campo situato nella finestra delle Preferenze.


Ora descriviamo l'ultima riga.  Il gadget "Salva Tutto" serve per salvare
tutta l'avventura:  il file contiene scene, oggetti, percorsi, spot,
dialoghi e preferenze, ovvero tutto quello di cui abbisogna il Player per
iniziare il gioco.  Il bottone "Salva Finale" differisce dal gadget "Salva
Tutto" poiché il file salvato verrà crittato:  l'Editor vi chiede la chiave
utilizzata per crittare il file.  Abbiamo aggiunto questa opzione poiché in
questo modo altre persone non possano guardare nel file Doopsi per vedere
come avete costruito la vostra avventura, ma possano comunque giocarci
senza bisogno di conoscere la chiave.  Il gadget "Carica Tutto" vi permette
di caricare un file salvato con il gadget "Salva Tutto" o "Salva Finale",
se volete modificarlo ulteriormente (se il file è crittato dovete conoscere
la chiave per decrittarlo prima di caricare i dati contenuti).  Il bottone
"Cancella Tutto" serve per cancellare tutto il vostro precedente lavoro e
ricominciare da capo.  Il bottone "Info su Doopsi" visualizza un piccolo
messaggio che dovreste leggere.



I gadget.

Sezione delle scene:

Nuovo             Crea una nuova scena: vi si chiede di selezionare
                  l'immagine di sfondo e di scrivere il nome della scena.

Carica            Carica un file contenente una o più scene.

Salva             Salva un file contenente dati per le scene: vi si chiede
                  se volete salvare solo la scena corrente o tutte le scene
                  create fino ad ora.

Lista             Lista tutte le scene create e vi permette di muovervi fra
                  le scene selezionando quella corrente.

Uccidi            Cancella la scena corrente.

Attrs             Apre lo Scene Attributes editor.

Spot editor       Invoca lo Spot editor.

Path editor       Accede al Path editor.

R                 Ridisegna lo schermo.


Sezione degli oggetti:

Nuovo             Crea un nuovo oggetto ed apre l'Object Attributes editor
                  per poterlo modificare.

Carica            Carica un file contenente uno o più oggetti.

Salva             Salva un file contenente dati per gli oggetti: vi si
                  chiede se volete salvare solo l'oggetto corrente o tutti
                  gli oggetti creati.

Lista             Lista tutti gli oggetti: potete muovervi fra di essi
                  selezionando quello corrente.

Uccidi            Cancella l'oggetto corrente.

Attrib            Apre l'Object Attributes editor.

Doopsi code       Invoca il Doopsi Coder.

Anim editor       Accede all'Anim editor.


Altri gadget:

Prefs             Apre l'editor delle Preferenze.

Dialog editor     Accede al Dialog editor.

Prova Gioco       Invoca il Player.

Info Progetto     Visualizza alcune informazioni sul vostro lavoro.

Carica Tutto      Carica un file contenente tutti i dati del gioco (se il
                  file è crittato vi viene chiesta la chiave per
                  decrittarlo).

Salva Tutto       Salva un file contenente tutti i dati del gioco, cioè il
                  file utilizzato dal Player.

Salva Finale      Salva un file crittato contenente tutti i dati del gioco:
                  l'Editor vi chiede la chiave per crittare il file.

Canc. Tutto       Elimina tutto il vostro precedente lavoro.

Info su Doopsi    Alcune note a proposito di noi e di Doopsi.


---------------------------------------------------------------------------


********************************************
Alcune note su come il Player trova l'Omino.
********************************************

Questo problema sorge in quanto l'Omino è un AnimObject (in realtà quattro
oggetti:  uno per ogni direzione) come tutti gli altri AnimObject che
potete agganciare al vostro gioco.  Quindi il Player deve sapere quali
oggetti rappresentano il protagonista della storia.  Il nome interno
dell'Omino è composto da una radice (quella di default è "Omino") ed una
estensione che indica la direzione (ad es.:  A per alto, G per giù, ecc.):
quindi l'AnimObject contenente l'animazione che rappresenta l'Omino che
cammina verso destra potrebbe essere chiamata (sempre nome interno!)
"OminoD", e così via.  Avete bisogno anche di altri quattro AnimObject
rappresentanti l'Omino che parla nelle quattro direzioni:  il nome di tali
AnimObject è costruito a partire dalla radice, aggiungendo ad essa una
prima estensione (quella di default è "Parla") e la seconda estensione è la
direzione, come prima.  Quindi un nome tipico per l'AnimObject
rappresentante l'Omino che parla verso sinistra è "OminoParlaS".

Potete scegliere la radice e le estensioni che preferite scrivendole
nell'editor delle preferenze.

Un'ultima nota a proposito di estensioni.  Il Doopsi Coder contiene
istruzioni utilizzate per muovere (e/o animare) oggetti sulla scena durante
il gioco:  vi si chiede di fornire il nome dell'AnimObject contenente
l'animazione desiderata.  E qui arriva la parte interessante:  se tale nome
termina con una delle quattro estensioni indicanti una direzione, allora il
Player è autorizzato a scegliere la direzione che gli serve.  Fa ciò
rimuovendo l'estensione e rimpiazzandola con quella indicante la direzione
giusta, poi cerca un AnimObject con il nome risultante dall'operazione
precedente e, se lo trova, lo usa.  Per esempio:  se il nome che avete
selezionato come argomento per l'istruzione SetMoveAnim è "VolaD" e la
mosca si deve muovere verso l'alto, allora il Player cerca un AnimObject
chiamato "VolaA".  In altre parole:  l'estensione che voi fornite al
momento della programmazione è irrilevante perché verrà rimpiazzata prima
di essere utilizzata, ma essa dice al Player di stare attento alla
direzione.  Per sapere quali istruzioni hanno questa opzione consultate
l'Appendice A.



Osservazioni generali che dovreste leggere:

L'Editor produce un file contenente la struttura della vostra avventura, ma
non la grafica o i suoni che avete agganciato al gioco poiché non vogliamo
mescolare tutta l'avventura in un solo file enorme; quindi nel file
generato vi sono solo i percorsi dei file agganciati.  Dovete ricordarvi di
questo particolare se volete distribuire il vostro gioco agli amici:  per
esempio, potete far diventare relativi i percorsi utilizzando
un'assegnamento.


---------------------------------------------------------------------------


************
Path Editor.
************

Introduzione.

Il Path Editor si occupa di aiutare il creatore dell'avventura a sviluppare
i percorsi nei quali si muoveranno i vari personaggi.  La creazione dei
percorsi è forse una delle cose più complesse e richiede una certa
attenzione.  A ben vedere, il percorso che verrà creato su di una scena
vincolerà i movimenti dei personaggi durante il gioco.  Questo deve
necessariamente portare ad una pianificazione ponderata per la creazione
del percorso.


Teoria dei path.

Il percoso, o path, è strutturato in nodi, delle unità di sosta.  Ogni nodo
può avere delle caratteristiche particolari che permettono un maggiore
controllo del movimento del personaggio sulla scena.  Di queste
caratteristiche parleremo più avanti.  Ogni nodo ha dei "rami" (branch) al
massimo sette per ogni nodo, che permettono di collegarsi ad altri nodi.

Il path determina, attraverso i nodi, la possibilità di movimento del
personaggio sulla scena.  Un percorso è quindi formato da nodi, uniti tra
loro da collegamenti (branch), in modo da formare una specie di "rete".  I
movimenti del personaggio dell'avventura sulla scena avverrà appunto su
questa rete, come se i nodi con le loro diramazioni fossero una specie di
"binario invisibile" sul quale il personaggio si muove.  Non è possibile,
in alcun modo, muovere il personaggio in zone della scena non raggiungibili
da un nodo.  Se si chiede al personaggio di muoversi in un luogo esterno
alla diramazione del percorso, verrà raggiunto il punto ritenuto più vicino
a quello richiesto, ma non si andrà oltre.  Questo aspetto dei path può
sembrare una limitazione, ma è in realtà una delle caratteristiche che
assicurano una grandissima flessibilità a livello di game-design:  per
esempio, è possibile creare una scena che racchiude più percorsi e
"vietare" l'accesso a certe aree a meno che non si siano verificate
determinate condizioni.

Con un po' di pratica, riuscirete sicuramente a creare dei percorsi
complessi ed articolati.  Il Path Editor vi assisterà costantemente e con
affidabilità in questo compito.  Buon lavoro.


NOTA:  I seguenti tutorial presuppongono che voi conosciate già altre
caratteristiche proprie di Doopsi, quali la creazione di nuove scene, la
creazione di animazioni tramite AnimWorkshop e la gestione degli oggetti
tramite l'editor di Attributi dell'Oggetto.

Tutorial 1 - Un Semplice Percorso

In questo tutorial impareremo a disegnare un piccolo percorso di quattro
nodi e ad unire questi nodi tra loro con delle semplici diramazioni.  Scopo
di questo tutorial è di impratichirvi con i comandi di base del Path
Editor.  Imparerete ad aggiungere e cancellare nodi, ad aggiungere
collegamenti e a forzare il ridisegnamento di tutta la scena (necessario in
alcuni casi).  Nel prossimo tutorial costruiremo qualcosa di più complesso.
Eseguite questa esercitazione anche più volte, fino a quando non sarete
certi di avere completa padronanza dei comandi.

Per eseguire questo tutorial dovrete aver creato prima una scena con
l'immagine "tutorial_room1".

Premete Path Editor nel pannello principale di Doopsi.

Non fatevi spaventare dal numero di pulsanti che ci sono, col tempo ne
avrete piena padronanza.

Prima di tutto, è consigliabile sistemare tutti i nodi che si desiderano
sullo schermo.  Naturalmente è possibile aggiungerne anche in seguito, ma
in questo modo sarete certi di coprire almeno tutti i punti importanti.

Per aggiungere un nodo sulla scena è sufficiente eseguire questi passaggi:

   - Premete "Agg. Nodi"
     Da questo momento in poi, fino a quando non decideremo di smettere,
     ogni click del mouse sulla scena darà origine alla creazione dei nodi.

   - Create quattro nodi in modo che formino una specie di quadrato.

   - Premete "Agg. Coll." per aggiungere i collegamenti.
     Da questo momento in poi, fino a quando non decideremo interrompere
     l'operazione, potremo aggiungere collegamenti tra i nodi.

   - Premete sul primo nodo (il nodo cambierà di colore)
   - Premete sul secondo nodo (il nodo cambierà di colore e una linea unirà
     i due nodi)

   Abbiamo appena creato il primo collegamento.  Per creare il secondo,
   procediamo in questo ordine:

   - Premete sul secondo nodo (il nodo cambierà colore)
   - Premete sul terzo nodo (il nodo cambierà colore e una linea unirà i
     due nodi)

   Proseguite in questo modo fino a quando non avrete creato un vero
   "quadrato".

Adesso che avete creato questi nodi, potete testare lo spostamento che
effettuerà il personaggio durante l'avventura:

   - premete il bottone "Prova Movim." e selezionate il nodo di partenza
     (per esempio il primo).  Il nodo si illuminerà.

   - Selezionate il secondo nodo (ad esempio il terzo).  Il nodo si
     illuminerà.

Il programma cercherà di calcolare un percorso tra i due nodi selezionati e
lo visualizzerà, passo passo, illuminando i nodi.  Se avete selezionato il
primo ed il terzo e li avete collegati come descritto nel nostro esempio,
dovreste vedere illuminarsi i nodi uno, due e tre.  Naturalmente questo è
un esempio semplice, ma la possibilità di provare il path si rivela molto
utile in scene complesse.

Adesso create un nuovo nodo dove volete e collegategli altri nodi, seguendo
i procedimenti appena descritti.  Riprovate ad utilizzare "Prova Movim.".

Prima di terminare il tutorial, proviamo a rimuovere un nodo dalla scena:

   - Premete "Uccidi Nodo"
   - Selezionate il nodo che intendete cancellare.
   - Il nodo verrà cancellato.

A questo punto, è possibile che della grafica sulla scena sia rovinata e
che il nodo appena cancellato compaia ancora.  Questo non è un errore di
Doopsi, ma è necessario eseguire un aggiornamento della grafica (refresh).
Premete "Aggiorna" per aggiornare la grafica, vedrete che adesso il nodo
cancellato non comaprirà più.


Tutorial 2 - La programmazione dei nodi

I percorsi sono strumenti potentissimi.  Per utilizzarli al meglio è
necessario provare e riprovare.  Quello che cercheremo di spiegarvi adesso
è la "programmazione" di un nodo.

Un nodo puo' essere programmato per le seguenti attività:

   - Modificare l'animazione del personaggio
   - Modificare la priorità uomo/oggetti
   - Determinare il cambio di scena
   - Controllare se un nodo è percorribile (controllo di condizione)

Tutte queste operazioni sono complesse da realizzare e richiedono uno
strudio accurato della generazione del percorso.

Vediamo adesso come è possibile programmare un nodo e quali sono le
condizioni da tenere in considerazione nella progettazione di un percorso.

Per programmare un nodo, è sufficiente premere il bottone "Codice" nel Path
Editor e poi selezionare il nodo che si intende modificare.

   - Modificare l'animazione del personaggio

     Premere il bottone "Setta Anim.", apparirà un Lister con tutti gli
     oggetti (animati e non) presenti nell'avventura. Selezionate quello
     che vi riguarda (Deve essere un AnimObject).

   - Modificare la priorità uomo/oggetti

     Premete il bottone "Cambia Pri", verranno alternate le scritte "Uomo
     Su Oggetti" o "Oggetti Su Uomo".

   - Determinare il cambio di scena

     Premere su "Set Start", apparirà un Lister contenente tutte le scene
     create. Selezionate quella nella quale desiderate spostarvi quando il
     personaggio passerà sopra al nodo.

   - Controllare se un nodo è percorribile (controllo di condizione)

     Premete "Set Condizione", apparirà un Lister con tutti i nomi degli
     oggetti presenti nell'avventura. Selezionato l'oggetto, comparirà
     uno status requester per determinare la condizione che andrà
     controllata su quel determinato nodo.



Facciamo un piccolissimo esempio di utilizzo:

Immaginate di avere i seguenti nodi:



    1 ---- 2 ---- 3 ---- 4 ---- 5


Noi vogliamo che il nodo 5 ci faccia saltare alla scena "Ufficio", ma solo
quando l'oggetto "porta" è aperta (supponiamo che lo status sia a 1 quando
la pora è aperta).  Dobbiamo fare in modo che il protagonista NON possa
raggiungere il nodo n.5 se non quando la porta è aperta.

Iniziamo a programmare il nodo 5.  Premete "Codice" e poi sul nodo 5, e
cliccate su "Set Start", selezionando la scena "Ufficio":  da ora in poi
tutte le volte che il personaggio arriverà sul nodo n.5, passerà alla scena
"Ufficio".

Ora programmate il nodo n.4:  premete "Codice" poi selezionate il nodo e
cliccate su "Set Condizione".  Premete sull'oggetto "Porta" e inserite come
valore di status 1.  Fatto!  Adesso, se la porta è chiusa, il nodo n.5 non
sarà raggiungibile.



Descrizione generale.

Probabilmente questo è l'editor con più bottoni, ma questi gadget sono
raccolti in gruppi.  Esamineremo un gruppo alla volta.

Il primo gruppo che mi accingo a descrivere è quello situato nell'angolo in
alto a sinistra della finestra.  Il bottone "Agg.  Nodi" attiva l'aggiunta
dei nodi, cioè, dopo aver premuto questo gadget potete aggiungere quanti
nodi volete fino a quando siete soddisfatti:  dovete solo cliccare sulla
scena nel punto dove volete un nodo.  Per uscire dall'aggiunta dei nodi
dovete premere ancora il gadget "Agg.  Nodi" (o un altro gadget del
medesimo gruppo).  Il bottone "Uccidi Nodo" vi chiede di selezionare il
nodo da uccidere, dopo di che l'Editor lo rimuoverà dalla scena:  il nodo
"morto" lascerà un quadrato nero sulla scena, così, se volete restaurare la
vostra grafica, dovete premere il bottone "Aggiorna".  Il bottone
"Aggiorna" ridisegna tutta la grafica contenuta nella scena corrente.  Il
bottone "Agg.  Coll." serve per attivare l'aggiunta dei collegamenti:  per
aggiungere un collegamento fra due nodi premete prima sul nodo iniziale e
poi su quello finale.  Potete ripetere questi passaggi fino a quando non
avrete finito di collegare tutti i vostri nodi; quindi premete il bottone
"Agg.  Coll." ancora una volta per uscire dall'aggiunta dei collegamenti.
Il gadget "Codice" vi chiede di selezionare il nodo da programmare; per
terminare la sessione di programmazione premete ancora sul bottone
"Codice":  l'Editor vi chiederà di selezionare un'altro nodo da
programmare, ma potete cliccare nel campo del "Messaggio" per farlo
smettere definitivamente.

La programmazione dei nodi ci porta direttamente al gruppo intitolato
"Modifica Settaggi".  Il bottone "Setta Anim." è utilizzato per cambiare le
animazioni dell'Omino quando l'Omino passa su quel nodo:  l'Editor apre un
lister con tutti i nomi degli oggetti creati ed aspetta che l'utente
selezioni un nome dalla lista.  A questo punto il testo "Default" alla
sinistra del gadget viene rimpiazzato con il nome scelto.  Da questo nodo
in poi il Player userà la radice del nome scelto come radice per costruire
tutti i nomi delle animazioni dell'Omino (se questo non vi dice niente
allora dovreste leggere le "Alcune note su come il Player trova l'Omino"
situate appena dopo la sezione della Finestra Principale di questo
manuale).  Il gadget "Cambia Pri." alterna la priorità fra "Uomo Su
Oggetti" a "Oggetti Su Uomo" e viceversa:  la prima condizione significa
che l'Omino apparirà davanti a tutti gli oggetti mentre cammina verso quel
nodo, la seconda significa giusto il contrario (potete trovare altre note a
proposito di come questo funzioni nella sezione dedicata al Player del
manuale).  Il bottone "Set Start" apre un lister con i nomi di tutte le
scene create fino ad ora:  il nome della scena selezionata apparirà alla
sinistra del gadget nel campo "Start".  Se questo campo non è vuoto il
Player, quando l'Omino calpesta quel nodo, cerca una scena avente il nome
scelto; se la scena viene trovata allora il Player abbandona la scena
precedente ed entra in quella nuova.  Nella nuova scena l'Omino verrà
posizionato sul nodo contenente (nel campo "Start") il nome della scena da
cui l'Omino proviene.  (E' come se il nodo "finale" della prima scena punti
verso il nodo "iniziale" della seconda, e viceversa.)

Il prossimo gruppo è quello chiamato "Condizioni".  Il bottone "Set
Condizione" permette all'utente di arrestare l'Omino se una determinata
condizione non è verificata:  la condizione è del tipo "Se lo stato
dell'oggetto è uguale a".  Il bottone apre un lister con i nomi degli
oggetti; dopo aver selezionato un oggetto dovete inserire il valore dello
stato che volete controllare.  Se il campo di Stato dell'oggetto
selezionato non contiene il valore scelto quando l'Omino cammina su quel
nodo, allora all'Omino non è permesso oltrepassare tale nodo.  Il gadget
"Cancella Condiz." cancella i campi di condizione del nodo.

Il bottone "Prova Movim." vi permette di vedere come l'Omino camminerà sul
vostro percorso:  vi si chiede di selezionare il nodo di partenza ed il
nodo di arrivo; a questo punto l'Editor illuminerà i nodi su cui l'Omino
passerà mentre va dal nodo iniziale a quello finale.  Il bottone "Controlla
Nodi" controlla se tutti i nodi sono correttamente collegati e rimuove i
nodi isolati.

Ci mancano solo tre gadget.  Il bottone "Nuovo Path" cancella completamente
il path attuale.  Il gadget "Salva Path" salva il path corrente in un file,
e il gadget "Carica Path" carica un file salvato con il precedente bottone.



Alcuni suggerimenti utili:

Premete sempre il bottone "Controlla Nodi" prima di salvare tutto il vostro
lavoro, poiché in questo modo vi eviterete sgradite sorprese.

Quando posizionate i nodi non dimenticatevi delle dimensioni dell'Omino:
l'hot spot dell'Omino è posizionato nell'angolo in basso a sinistra
dell'immagine dell'Omino, quindi l'Omino si ferma sempre alla destra di un
nodo.  Questo implica che l'Omino può raggiungere il bordo destro (o il
bordo superiore) della scena prima di raggiungere il nodo di destinazione
se posizionate tale nodo troppo vicino al bordo della scena:  quando
l'Omino raggiunge il bordo della scena si ferma, così il vostro nodo non
verrà mai raggiunto.

Quando stabilite la priorità dell'Omino sugli oggetti tenete presente le
dimensioni dell'Omino:  se un nodo dice "Oggetti Su Uomo" ed il seguente
dice "Uomo Su Oggetti" e l'Omino, andando dal primo al secondo nodo, è
ancora parzialmente coperto da un oggetto, esso può venire improvvisamente
posizionato davanti all'oggetto che lo copre.  Di conseguenza vi capiterà
spesso di dover scegliere la priorità "Oggetti su Uomo" anche per un nodo
che non è coperto da alcun oggetto per essere sicuri che l'Omino sia
completamente scoperto prima di cambiare la sua priorità.



I gadget.


Agg. Nodi         Attiva l'aggiunta dei nodi: cliccate sulla scena per
                  posizionare quanti nodi volete, e poi cliccate su questo
                  gadget per uscire dall'aggiunta.

Uccidi Nodo       Chiede di selezionare un nodo e poi lo cancella. Cliccate
                  ancora su questo bottone per annullare l'operazione.

Agg. Coll.        Attiva l'aggiunta dei collegamenti: cliccate sul nodo
                  iniziale e su quello finale fino a quando non avrete
                  posizionato tutti i colegamenti. Premete ancora questo
                  gadget per uscire dall'aggiunta.

Codice            Attiva la sessione di programmazione. Quando avete finito
                  di cambiare gli attributi del nodo premete ancora questo
                  bottone.


Aggiorna          Ridisegna tutta la grafica della scena.


Setta Anim.       Cambia il campo "Anim" del nodo.

Cambia Pri        Cambia la priorità dell'Omino rispetto agli oggetti.

Set Start         Seleziona la scena in cui entrare quando l'Omino cammina
                  su questo nodo.


Set Condizione    Stabilisce la condizione che deve essere verificata
                  affinché l'Omino possa oltrepassare il nodo.

Cancella Condiz.  Cancella il campi di condizione di un nodo.


Nuovo Path        Cancella il path corrente.

Salva Path        Salva il path corrente in un file.

Carica Path       Carica un path da un file.


---------------------------------------------------------------------------


************
Spot Editor.
************

Questo vi permette di posizionare degli "Spot" sulla scena:  essi sono
semplicemente delle piccole crocette con due coordinate ed un nome.  Voi
usate questo nome per designare un particolare spot e Doopsi userà le sue
coordinate.  Gli spot vengono usati assieme, ad esempio, all'istruzione
MoveObject per indicare il posto dove l'oggetto dovrà recarsi.


Eccovi un TUTORIAL:

- Create una nuova scena (utilizzando il bottone "New" nella sezione
dedicata alle scene della finestra principale dell'editor).

- Attivate lo Spot editor.

- Selezionate il gadget "Aggiungi Spot":  apparirà il messaggio "Aggiungi
gli spot".

- Cliccate sulla scena dove volete mettere uno spot:  potete ripetere
questa operazione fino a quando avrete posizionato tutti i vostri spot.

- Selezionate ancora il bottone "Aggiungi Spot" per disattivare il modo di
aggiunta degli spot.

- Cliccate sulla scena per selezionare uno spot:  apparirà il messaggio
"Informazioni".

- Potete modificare il nome dello spot corrente semplicemente scrivendolo
nello string gadget "Nome Spot" e premendo Return.

- Uscite dallo Spot editor.



Descrizione generale.

Per aggiungere alcuni spot dovete cliccare sul bottone "Aggiungi Spot":
quindi cliccate sulla scena ovunque vogliate posizionare uno spot.  Poiché
uno spot senza un nome non ha senso lo Spot Editor attribuisce ai vostri
spot un nome di default, nome che potete cambiare in ogni momento
semplicemente riscrivendolo nel gadget stringa chiamato "Nome Spot" e
premendo Return.  D'ora in poi potete aggiungere spot a vostro piacimento.
Quando siete soddisfatti, potete interrompere l'aggiunta di spot premendo
ancora il bottone sinistro del mouse sul gadget "Aggiungi Spot" o su quello
chiamato "Elimina Spot" o, infine, su qualunque parte della finestra
dell'editor.  Per eliminare uno spot premete una volta il gadget "Elimina
Spot":  l'editor vi chiederà di scegliere lo spot da uccidere, e quindi non
vi rimane che cliccare su tale spot.  Questo è tutto.  A proposito, dopo
aver ucciso uno spot (o dopo aver deciso di non ucciderlo cliccando ancora
nella finestra dell'editor) è necessario riselezionare il gadget "Elimina
Spot" per ucciderne un'altro, e così via.

L'azione di default (quando non state aggiungendo o eliminando spot) è
chiamata "Informazioni":  siete liberi di cliccare su qualunque spot per
illuminarlo e visualizzare il suo nome nello string gadget.  Come ho detto
in precedenza, questo nome può essere modificato ogni volta che viene
visualizzato.

Manca ancora un gadget:  il bottone "Aggiorna".  Dopo aver posizionato (ed
eliminato) molti spot la vostra scena potrebbe apparire un po' sottosopra:
cliccate su questo gadget e Doopsi pulirà la stanza per voi.


I gadget:

Aggiungi Spot     Attiva (e disattiva) l'aggiunta degli spot.

Elimina Spot      Cancella uno spot.

Nome Spot         Modifica il nome dello spot.

Aggiorna          Ridisegna la scena.


---------------------------------------------------------------------------


*************************
Screen Attributes editor.
*************************

Questo editor vi permette di cambiare il nome della scena corrente, di
caricare uno sfondo diverso senza rimuovere oggetti, percorso e spot che
avete già agganciato a quella scena, ed altre cose utili...

L'ultima riga in basso dice qualcosa del genere:  "Usa Azione Apri di
Oggetto pippo".  In altre parole il codice Doopsi contenuto nell'azione
specificata dell'oggetto selezionato verrà eseguito tutte le volte che
entrerete nella scena durante il gioco.  Per disattivare questa opzione
dovete cancellare il nome dell'oggetto nello string gadget.  Un
suggerimento utile:  se volete che il codice sia eseguito solo la prima
volta in cui entrate nella scena (o in occasioni speciali) potete sfruttare
il campo di stato dell'oggetto:  inserite in questo campo un valore
particolare ed iniziate il codice Doopsi con l'istruzione "IfStatus".


I gadget:

Cambia Sfondo     Carica un nuovo sfondo per la scena. Se almeno un nodo
                  del percorso esistente o uno spot cadono al di fuori
                  della bitmap allora l'editor vi avviserà senza, però,
                  rimuovere l'oggetto incriminato.

Nome Scena        Cambia il nome interno della scena.

Nome Musica       Potete inserire il nome di un modulo che verrà suonato
                  ogni volta che entrerete nella scena (durante il gioco,
                  ovviamente) e verrà interrotto quando uscirete dalla
                  scena stessa. Potete cliccare sul bottone per aprire un
                  file requester e selezionare il modulo, oppure potete
                  scriverne direttamente il nome nel gadget stringa.

Usa Azione        Questo cycle gadget vi permette di scegliere l'azione da
                  cui leggere il codice Doopsi che è eseguito quando
                  entrate nella scena durante il gioco.

di Oggetto        Seleziona l'oggetto da cui leggere il codice Doopsi
                  specificato dal gadget "Usa Azione". Questo bottone apre
                  una lista con i nomi di tutti gli oggetti. Potete anche
                  inserire il nome dell'oggetto a mano utilizzando il
                  gadget stringa.


---------------------------------------------------------------------------


***************************************
L'Editor degli Attributi di un Oggetto.
***************************************

Questo editor vi permette di specificare le caratteristiche di un oggetto e
di posizionarlo sulla scena.


Un primo tutorial: "il foglietto".

- Suppongo che abbiate già caricato una scena per potervi posizionare degli
oggetti.  Ora create un nuovo oggetto premendo il bottone "Nuovo" nella
sezione dedicata agli oggetti della finestra principale.

- Attivate l'editor degli Attributi.

- Nel gadget "Nome" scrivete "il foglietto".

- Cliccate sul gadget "Nome Interno" e scrivete "foglietto".

- Cliccate sul cycle gadget per selezionare "Grafica" come tipo di oggetto,
in quanto il nostro oggetto dovrà essere disegnato sulla scena.

- Premete il bottone "Agg." e, usando il file requester, scegliere
l'immagine "paper" nella directory Tutorial.  Ora l'immagine è agganciata
all'oggetto.

- Infine premete il bottone "Pos" per posizionare l'oggetto sulla scena.

- Potete muovere l'oggetto nella sua posizione finale selezionandolo con il
mouse e trascinandolo all'interno della scena.


Un secondo tutorial: "una zona vuota".

- Create un nuovo oggetto come nel precedente tutorial.

- Scrivete il suo nome e (più importante) il suo nome interno.

- Cliccate sul cycle gadget per selezionare "Vuota" come tipo di oggetto:
il nostro oggetto sarà una cornice vuota (che non verrà disegnata sullo
schermo durante il gioco).

- Premete il bottone "Setta Zona": un rettangolo apparirà sulla scena.

- Trascinate il rettangolo nella scena con il mouse e scalatelo utilizzando
il gadget posizionato nell'angolo in basso a destra del rettangolo stesso.

- Quando avete finito premete il gadget "Pos" per agganciare questo oggetto
alla scena.



Descrizione generale.

Potete attivare questo editor cliccando sul bottone "Attrib" nella sezione
dedicata agli oggetti della finestra principale o cliccando il tasto destro
del mouse su un oggetto già posizionato sullo schermo.

I primi campi che dovete riempire sono quelli indicati con "Nome" e "Nome
Interno":  il nome di un oggetto è la stringa che appare sulla linea di
testo della console del Player quando il puntatore è su tale oggetto; il
nome interno è l'identificatore che Doopsi usa per indirizzare un oggetto:
per questa ragione siete invitati a non usare più volte lo stesso nome.

Dopodiché concentriamoci sulla zona delle immagini.  Per aggiungere alcune
immagini al vostro oggetto dovete cliccare sul bottone "Agg.":  l'editor
aprirà un file requester e, dopo che avrete selezionato un file valido,
visualizzerà il nome dell'immagine (completa di percorso) nella lista.  Per
eliminare un'immagine non dovete far altro che cliccare su tale immagine e
poi premere il bottone "Uccidi".  Poi dovete dire all'editor quale immagine
usare per disegnare l'oggetto sulla scena; per far ciò selezionate una
immagine nella lista a premete il gadget "Shp Def.":  apparirà un numero
che mostra qual è l'immagine corrente.  Una procedura simile è necessaria
per dire al Player qual è l'immagine di inventario:  cliccate su
un'immagine e poi sul bottone "Shp Inv.".  A proposito:  le immagini di
inventario devono avere dimensioni di 32*32 pixel, altrimenti verranno
tagliate prima di essere visualizzate dal Player.  Vi è ancora un gadget da
descrivere:  il cycle gadget è necessario per scegliere se si vuole un
oggetto "Grafico" od uno "Vuoto".  Il primo ha un'immagine corrente che
viene disegnata sulla scena, mentre il secondo è solo un rettangolo vuoto
utilizzato per incorniciare qualcosa appartenente allo sfondo.  Per
posizionare e ridimensionare tale rettangolo dovete cliccare sul bottone
"Setta Zona":  una Zona Vuota verrà disegnata sulla scena, zona che potete
trascinare col mouse cliccando su di essa; per riscalarla premete
semplicemente sul quadrato pieno nell'angolo in basso a destra della zona
stessa.  E' importante notare che anche oggetti Vuoti possono avere alcune
immagini agganciate:  potete usare queste immagini con i comandi del Player
che riguardano l'inventario.  Ciascun oggetto ha spazio per più di una
immagine e più di una immagine di inventario poiché durante il gioco potete
cambiare l'immagine corrente dell'oggetto o la sua immagine di inventario
utilizzando le istruzioni del Player relative alle immagini.

Nel gadget "Stato" potete inserire il valore di partenza dello stato
dell'oggetto.  Il campo di stato è un valore intero privo di un significato
particolare, dimodoché lo potete usare per qualunque scopo vi aggradi, ad
es.:  potete memorizzare qui lo stato Aperto/Chiuso di una porta scrivendo
0 per Chiuso e 1 per Aperto, e potete cambiare questo stato durante il
gioco usando ChangeStatus ed altre istruzioni del Player.

Uscendo da questo editor ricordate di premere sempre il bottone "Pos" se
volete agganciare l'oggetto alla scena, anche se l'avete già fatto in
precedenza:  questo perché il gadget "Ok" accetta le modifiche apportate
all'oggetto ma sgancia sempre tale oggetto dalla scena.  Non c'è bisogno di
spiegare cosa fa il gadget "Cancella".


I gadget:

Nome           Nome dell'oggetto.

Nome Interno   Nome interno dell'oggetto.

Shp Def.       Questo intero punta all'immagine utilizzata per disegnare
               l'oggetto sulla scena. Non ha significato alcuno per una
               Zona Vuota.

Shp Inv.       Questo intero punta all'immagine utilizzata dal Player per
               immagazzinare l'oggetto nell'inventario (le dimensioni di
               questa immagine devono essere di 32*32 pixel).

Vuota/Grafica  Seleziona il tipo di oggetto.

Agg.           Aggancia un'immagine all'oggetto e aggiunge il suo nome alla
               lista.

Uccidi         Rimuove un'immagine dalla lista.

Stato          Modifica il valore corrente dello stato.

Setta Zona     Crea il rettangolo di una Zona Vuota.

Pos            Esce agganciando l'oggetto alla scena.

Ok             Esce senza agganciare l'oggetto alla scena (se l'oggetto è
               già agganciato, allora questo gadget lo sgancia).

Cancella       Esce ripristinando le condizioni iniziali.


---------------------------------------------------------------------------


*************
Doopsi Coder.
*************

Introduzione.

Doopsi Coder è l'editor che vi permette di "programmare" gli oggetti a
reagire alle azioni dell'utente.  Per il player di DOOPSI, gli oggetti non
sono altro che complesse strutture di dati senza però alcun vero
significato.  Compito del Coder è di permettere un coordinamento tra le
azioni possibili dal giocatore e il comportamento di ogni oggetto.  Il
Coder è forse la parte più importante nell'editing di una avventura, in
quanto permette effettivamente al creatore della storia di dare una forma
"reale" agli oggetti in scena e di permettere al giocatore di interagire
con gli oggetti stessi.

La teoria che è alla base del Doopsi Coder è molto semplice:  ad ogni
azione permessa all'utente potrebbe corrispondere una reazione da parte
dell'oggetto interessato.  Abbiamo detto "potrebbe" perché non è necessario
che ogni oggetto sia in grado di rispondere a tutte le azioni che l'utente
desidererebbe effettuare.  Se ad esempio il giocatore volesse parlare con
la porta, quest'ultima non è tenuta a rispondere (a meno che non si tratti
di una porta magica...)

La programmazione degli oggetti in Doopsi avviene all'interno del Coder,
che garantisce un ambiente semplice e rapido per la loro organizzazione.
Non preoccupatevi se non avete dimestichezza con la programmazione:  non
dovrete scrivere neppure una linea di codice, in quanto il Coder rende
questo compito accessibile a chiunque:  tutto quello che dovrete fare è di
avere bene in mente quello che desiderate ottenere da una determinata
azione su di uno specifico oggetto.


Nozioni generali di OOP in Doopsi.

Doopsi significa "Dynamic Object Oriented Programming System Interface",
Interfaccia di Sistema per la Programmazione Dinamica Orientata agli
Oggetti.  I programmatori smaliziati noteranno che in Doopsi non è
presente un vero e proprio interprete OOP, bensì è Doopsi stesso che si
occupa di gestire l'interfacciamento oggetto-codice.  Per questo la
programmazione OOP in Doopsi è Dinamica:  gli oggetti possono mutare forma
e caratteristiche "al volo".  Gli oggetti sono visti come delle "entità",
un insieme di dati e caratteristiche che li rendono unici e riconoscibili.
Tutti i dati contenuti all'interno di un oggetto sono protetti e non
direttamente accessibili.  L'accesso è garantito solo tramite le istruzioni
del Doopsi Language che si occupa di "smistare" i comandi e di accedere
correttamente ai dati desiderati.  Molti comandi chiedono come primo
parametro il nome interno dell'oggetto sul quale dovranno agire.  Questo
significa che il codice di un oggetto può modificare le caratteristiche di
un altro oggetto del gioco.  Ogni oggetto possiede uno "Status", un valore
che può essere modificato con del codice Doopsi e che rappresenta quello
che il programmatore desidera:  il valore di Status è arbitrario e non è
legato all'oggetto, dipende al programmatore definire come utilizzare
Status.

I comandi del Doopsi-Language sono elencati completamente nell'Appendice A.


NOTA:  i seguenti tutorial presuppongono che voi abbiate padronanza di
altre parti di Doopsi, come l'Editor degli Attributi dell'Oggetto.  Vedere
i Tutorial del capitolo "Creazione di Oggetti" se non si hanno ben chiari i
principi della creazione degli oggetti.


Tutorial 1 - Una porta che si apre e si chiude

Questo esempio presuppone che abbiate già creato un oggetto chiamato
internamente "door" che possiede due immagini, la prima raffigurante la
porta chiusa ("door_closed") e la seconda raffigurante la porta aperta
("door_open").

- Dall'editor principale, selezionate l'oggetto "door" come corrente e
premete il bottone Doopsi Coder, sarete così pronti a programmare
l'oggetto.

- Premete il bottone "Apri" per programmare la reazione dell'oggetto
"door" all'azione "Apri".  Eseguite questi passi:

    - Comando "IfStatus"
    - Selezionate l'oggetto "door"
    - Inserite 0 come valore
    (Nella finestra del Coder comparirà il comando: IfStatus SELF, 00)
    - Comando "ChangeStatus"
    - Selezionate l'oggetto "door"
    - Inserite 1 come valore
    (Nella finestra del Coder comparirà il comando: ChangeStatus SELF, 01)
    - Comando "ChangeShape"
    - Selezionate l'oggetto "door"
    - Selezionate l'immagine raffigurante la porta aperta (ad es. "door_open")
    (Nella finestra del Coder comparirà il comando: ChangeShape SELF, 01)
    - Comando "Else"
    - Comando "ShowText"
    - Inserite "La porta è già aperta"
    (Nella finestra del Coder comparirà il comando:  ShowText La portà è già
   aperta)
   - Comando "EndIf"

Al termine della sequenza appenna effettuata, nella finestra del Coder
comparirà questo codice:

    IfStatus SELF, 00
    ChangeStatus SELF, 01
    ChangeShape SELF, 01
    Else
    ShowText La porta è già aperta
    EndIf

Questo codice significa (spiegato riga per riga):

    Se lo status dell'oggetto stesso (SELF, la porta) è 0
    Cambia lo status dell'oggetto stesso (SELF, la porta) a 1
    Cambia l'immagine dell'oggetto stesso (sempre la porta) a 1 ("door_open")
    Altrimenti (Else)
    Mostra il Messaggio "La porta è già aperta"
    Fine del controllo.

Scriviamo adesso il codice necessario per l'azione "Chiudi".  Premete il
bottone "Chiudi" per programmare la risposta dell'oggetto porta all'azione
di chiusura.  Eseguite questi passi:

    - Comando "IfStatus"
    - Selezionate l'oggetto "door"
    - Inserite il valore 1
    - Comando "ChangeStatus"
    - Selezionate l'oggetto "door"
    - Inserite il valore 0
    - Comando "ChangeShape"
    - Selezionate l'oggetto "door"
    - Selezionate l'immagine "door_closed"
    - Comando "Else"
    - Comando "ShowText"
    - Inserite "La porta è già chiusa"
    - Comando "EndIf"

Comparirà il seguente codice:

    IfStatus SELF, 01
    ChangeStatus SELF, 00
    ChangeShape SELF, 00
    Else
    ShowText La porta è già chiusa
    EndIf

Che "tradotto" significa:

    Se lo Status dell'oggetto stesso (SELF, porta) è a 1
    Cambia lo Status dell'oggetto stesso (SELF, la porta) a 0
    Cambia l'immagine dell'oggetto stesso (SELF, sempre la porta) a 0 (la
      porta chiusa)
    Altrimenti
    Mostra Il Testo "La porta è già chiusa"

La programmazione del nostro oggetto "door" è terminata.  Premete il
bottone OK per tornare al Doopsi Editor.


Tutorial 2

In questo tutorial mostreremo come modificare le caratteristiche di un
oggetto da un altro oggetto.  Questo tutorial presuppone che voi abbiate
già creato due oggetti, uno chiamato "lamp" con due immagini, una di
lampadina spenta ("light_off") ed una accesa ("light_on"); e l'altro
chiamato "button", con una sola immagine, di bottone.

- Selezionate l'oggetto "button" ed entrate nel Doopsi Coder.

- Premete sul bottone "Spingi", per editare il codice riferito alla
pressione da parte del giocatore del bottone "button".

- Eseguite queste operazioni:

    - Comando "IfStatus"
    - Selezionate "lamp"
    - Inserite 0
    - Comando "ChangeStatus"
    - Selezionate "lamp"
    - Inserite 1
    - Comando "ChangeShape"
    - Selezionate "lamp"
    - Selezionate "light_on"
    - Comando "Else"
    - Comando "ChangeStatus"
    - Selezionate "lamp"
    - Inserite 0
    - Comando "ChangeShape"
    - Selezionate "lamp"
    - Selezionate "light_off"
    - Comando "EndIf"

Nella finestra di codice di Doopsi Coder, comparirà il seguente programma:

    IfStatus lamp, 00
    ChangeStatus lamp,01
    ChangeShape lamp,01
    Else
    ChangeStatus lamp,00
    ChangeShape lamp,00
    EndIf

Che "tradotto" significa:

    Se lo Status della lampada ("lamp") è 0 (la lampada è spenta)
    Cambia lo Status di lamp in 1 (lampada accesa)
    Cambia l'immagine di lamp a "light_on"
    Altrimenti (la lampada è accesa)
    Cambia lo Status di lamp a 0 (lampada spenta)
    Cambia l'immagine di lamp a "light_off"

Come vedete dal codice, non abbiamo dovuto programmare l'oggetto "lamp",
eppure l'oggetto modifica il suo stato (anche grafico) man mano che il
giocatore preme il pulsante "button".  Naturalmente, questo tutorial è
molto semplice, ma è possibile creare dipendenze molto complesse tra
oggetti differenti, rendendo il gioco finale ricco e articolato.



Descrizione generale.

Prima di tutto dovete selezionare l'azione che vi apprestate a programmare:
per far ciò premete uno dei nove bottoni "Azioni Possibili" che compaiono
nell'angolo in alto a sinistra della finestra; il nome dell'azione scelta
comparirà nel campo "Azione Corrente" sul fondo della finestra.

Per inserire una qualsiasi istruzione eseguite le seguenti azioni:
cliccate sul nome dell'istruzione desiderata contenuta nel lister che si
trova alla destra delle "Azioni Possibili"; l'Editor vi chiederà di
riempire qualsiasi argomento l'istruzione potrebbe avere.  Dopo aver
soddisfatto tutte le richieste potrete vedere apparire la linea di codice
nell'area del programma (il grosso rettangolo con un linea evidenziata in
esso).  La barra nell'area del programma è una specie di cursore che
evidenzia la linea corrente.  L'istruzione che state editando verrà
inserita prima di quella evidenziata.  Potete muovere il cursore cliccando
direttamente sull linea scelta oppure usando i gadget U (Up), D (Dowm), T
(Top) e B (Bottom).  Per eliminare una linea premete semplicemente il
bottone "Uccidi".



I gadget:

Nella zona in alto a sinistra vi sono i nove gadget per selezionare una
delle nove azioni da programmare.  Alla destra di questa zona vi è il
lister con tutte le istruzioni del linguaggio Doopsi.  Gli altri gadget
sono:

T              Sposta all'inizio del codice.

B              Sposta alla fine del codice.

U              Sposta in su di una linea. (Per muovervi su una linea potete
               cliccare direttamente su quella linea.)

D              Sposta in giù di una linea.  (Per muovervi su una linea
               potete cliccare direttamente su quella linea.)

Uccidi         Rimuove la linea di codice attualmente evidenziata.


---------------------------------------------------------------------------


****************
L' AnimWorkshop.
****************

Questo editor vi permette di creare animazioni mettendo in sequenza alcune
immagini.  Il risultato è che potete mutare un semplice Oggetto in qualcosa
di più complesso chiamato AnimObject, ovvero un oggetto contenente
un'animazione.  Tale animazione verrà visualizzata quando l'AnimObject è
disegnato sulla scena.


Iniziamo con un veloce TUTORIAL:  "assemblare un pendolo"

- Create un nuovo oggetto con "Pendolo" come nome interno.

- Attivate AnimWorkshop.

- Premete il gadget "Carica Frames" e, utilizzando il file requester,
selezionate l'immagine denominata "pendulum.000".  AnimWorkshop caricherà
le tre immagini chiamate "pendulum.000", "pendulum.001" e "pendulum.002".

- Selezionate il fotogramma numero 0 e cliccate sul gadget "Agg Frame";
selezionate il fotogramma numero 1 e cliccate sul gadget "Agg Frame";
ripetete il tutto anche per il terzo ed ultimo fotogramma.

- Premete il gadget "Ping-Pong" per creare un'animazione di tipo Ping-Pong
(nel nostro caso verrà aggiunto un solo fotogramma).

- Scrivete 3 nel gadget del "Frame Rate".

- Premete "Anima" per vedere l'animazione e il tasto destro del mouse per
fermarla.

- Premete il gadget "Ok" per uscire da AnimWorkshop.


Ed eccovi un tutorial più difficile su "come costruire l'Omino":

- Per prima cosa create un nuovo oggetto utilizzando l'editor degli
Attributi (suppongo che sappiate già fare questo) e chiamatelo (nome
interno) "OminoDestra".  Ora siete pronti per attivare AnimWorkshop.

- Premete il bottone "Carica Frames" e, utilizzando il file requester,
selezionate l'immagine chiamata "man_walk_right.000":  AnimWorkshop
caricherà questa immagine e tutte le seguenti col medesimo nome e numero
crescente; questi fotogrammi saranno disegnati su un nuovo schermo.  Potete
scorrere le immagini utilizzando i gadget "Prec" e "Succ" nella parte alta
della finestra.

- Posizionatevi sul fotogramma numero 1 (il fotogramma 0 è quello "a
riposo" e lo prenderò in considerazione più tardi) e premete il bottone
"Agg Frame":  il numero 1 apparirà nella finestra della Sequenza.  Ora
muovetevi sul fotogramma numero 2 e premete ancora su Agg Frame; ripetete
queste azioni fino a quando anche l'ultimo fotogramma farà parte della
sequenza.

- Ora potete inserire il frame rate nel gagdet "Frame Rate":  scrivete 12 e
premete Return.

- La vostra animazione è completa:  premete il gagdet "Anima" per
ammirarla.

- Fermate l'animazione premendo il tasto destro del mouse.  Ora potete
uscire da AnimWorkshop premendo il bottone "Va Bene" o "Cancella" a seconda
se siete soddisfatti della vostra animazione o meno.

- E il frame numero 0?  Non si può includerlo nell'animazione perché è il
fotogramma "a riposo", ma il Player ha bisogno di sapere quale frame usare
quando l'Omino è fermo:  quindi noi lo agganciamo al nostro oggetto Omino e
puntiamo ad esso mediante il campo "Immagine Corrente" nell'editor degli
Attributi.  (Ovviamente questo campo non ha significato alcuno per una
animazione qualunque.)

- Un'ultima nota:  se ora attivate l'editor degli Attributi vedrete tutte
le immagini agganciate al nostro AnimObject mediante AnimWorkshop.  Questo
significa che potete agganciare i fotogrammi anche utilizzando l'editor
degli Attributi se preferite.



Descrizione generale.

A questo punto suppongo che sappiate già come creare un nuovo oggetto.  Se
volete convertire tale oggetto in un AnimObject allora attivate
l'AnimWorkshop.  Se l'utente ha già agganciato alcune immagini a questo
oggetto utilizzando l'editor degli Attributi allora tali immagini saranno
caricate e visualizzate immediatamente; se una o più immagini non vengono
trovate l'editor segnalerà un errore e le immagini mancanti rimarranno
vuote.  In alternativa è possibile caricare le immagini mediante
AnimWorkshop stesso:  ma si tenga presente che in questo caso le immagini
devono costituire una sequenza sul disco, vale a dire che devono avere
tutte il medesimo nome seguito da un punto e da un numero a tre (tre, non
quattro o due!) cifre, ad es.  "pippo.000".  Quindi, quando l'utente
seleziona il gadget Carica Frames, AnimWorkshop aprirà un file requester:
l'utente deve selezionare la prima immagine della sequenza (che non deve
necessariamente essere quella numerata "pippo.000"; potete iniziare
dall'immagine "pippo.154" se vi piace), ed allora l'editor proseguirà
caricando tutte le immagini che trova con il medesimo nome e con numero
crescente (ad es.:  "pippo.154", "pippo.155", e così via) fino a quando
raggiunge l'ultima o non ha più spazio per agganciare ulteriori immagini
all'oggetto corrente (il numero di immagini che un oggetto può possedere è
ovviamente limitato).

Dopo che avete caricato le immagini siete pronti per costruire la sequenza
dei fotogrammi.  Prima di tutto, vi sono due gadget nella parte alta della
finestra, chiamati "Prec" e "Succ", per scorrere i fotogrammi, e fra di
essi è scritto il numero sequenziale del fotogramma visualizzato:  potete
inserirlo manualmente.  Dunque dovete agire come segue:  selezionate il
fotogramma da includere nella sequenza e premete il bottone Aggiugi Frame.
Semplice, no?  Il fotogramma verrà inserito subito dopo la posizione
corrente, e voi saprete sempre qual è la posizione corrente in quanto è
evidenziata:  potete inoltre muovere questa specie di cursore utilizzando i
gadget "Prec" e "Succ" alla base della finestra o utilizzando i tasti
cursore.  A proposito, se occorre inserire un fotogramma prima del primo
(scusate il gioco di parole, ma rende l'idea) dovete muovere il cursore sul
primo fotogramma della sequenza e poi muoverlo ancora una volta verso
sinistra:  il cursore sparirà fuori dalla finestra della Sequenza e siete
pronti per cliccare sul gadget "Aggiungi Frame".  Posso dirvi di più:  se
cliccate due volte sul numero di un fotogramma nella finestra della
Sequenza tale fotogramma sarà visualizzato.  Rimuovere un fotogramma è
ancora più semplice:  posizionatevi sul fotogramma incriminato nella
Sequenza e cliccate sul bottone "Rimuovi Frame".

Veniamo ora alla descrizione dei gadget rimanenti.  Un modo comodo per
creare un'animazione a ping-pong è quello di costruire la parte "ping" come
descritto precedentemente e poi selezionare il gadget "Crea Ping-Pong":
AnimWorkshop aggiungerà alla vostra sequenza la parte "ping" ribaltata
(senza il primo e l'ultimo fotogramma) per creare la parte "pong".
Inoltre, se non siete soddisfatti della vostra sequenza potete sempre
eliminarla con una sola pressione del bottone "Cancella Sequenza".  Potete
comunicare ad AnimWorkshop la velocità della vostra animazione modificando
il valore del gadget "Frame Rate".  Ultimo ma non meno importante è il
gadget "Anima".  So che sapete a cosa serve questo, ma lasciatemi
aggiungere un'altra cosa:  Doopsi visualizza tutte le animazioni in loop,
ovvero la sequenza viene letta da sinistra a destra fino alla fine, e poi
ancora dall'inizio fino a quando non viene fermato.


I gadget:

Carica Frames     Carica una sequenza di fotogrammi. Una sequenza è
                  composta da files con lo stesso nome ma con numero
                  sequenziale crescente (ad es.: pippo.000, pippo.001,
                  ...). Voi selezionate il primo nome della lista.

Prec              Muove al fotogramma precedente nella lista.

Succ              Muove al fotogramma successivo nella lista.

Agg Frame         Aggiunge alla sequenza il fotogramma attualmente
                  visualizzato.

Canc Frame        Cancella il fotogramma selezionato dalla sequenza. Voi
                  selezionate il fotogramma muovendo il cursore sopra di
                  esso.

Crea Ping-Pong    Crea un'animazione a ping-pong modificando la vostra
                  sequenza di fotogrammi.

Frame Rate        Cambia il frame rate dell'animazione.

Cancella Sequenza Elimina la sequenza di fotogrammi.

Anima             Mostra l'animazione.

Prec              Va al fotogramma precedente nella sequenza (potete usare
                  anche i tasti cursore).

Succ              Va al fotogramma successivo nella sequenza.


---------------------------------------------------------------------------


**********************
L'Editor dei Dialoghi.
**********************

Introduzione.

In ogni avventura che si rispetti, devono essere presenti dei dialoghi tra
più personaggi.  Migliori sono i dialoghi, più brillanti sono le
conversazioni, più divertente risulta l'avventura.  Creare i dialoghi non è
un compito facile da eseguire:  bisogna tenere in considerazione moltissimi
elementi e prevedere una risposta differente ad ogni frase che è possibile
dire.  E' per questo motivo, che vi consigliamo vivamente di pianificare
attentamente i vostri dialoghi e di tracciare su carta dei veri e propri
diagrammi nei quali descrivere in maniera molto "visiva" come dovrebbe
essere strutturato un dialogo.

In Doopsi i dialoghi possono essere strutturati in maniera molto potente e
versatile ed è possibile scrivere dialoghi che richiamano altri dialoghi o
che saltano da una parte all'altra per poi tornare sui loro stessi passi.

Il Dialog Editor è uno strumento semplice e funzionale che vi permetterà di
creare dialoghi complessissimi in un brevissimo spazio di tempo:
attenzione però, perché, come vi abbiamo già detto, se non pianificherete
prima tutto il dialogo, rischiate veramente di perdere, per così dire, il
filo del discorso.


Cos'è un dialogo:

Un Dialogo, in DOOPSI, è formato da una sequenza più o meno lunga di
pagine.  Come per tutti gli altri elementi di Doopsi anche le pagine di
dialogo hanno il loro proprio "nome interno" che le identifica
univocamente.

Per il resto, una pagina è formata da una "risposta", che è la frase che
dirà l'interlocutore all'Omino, e una o più frasi selezionabili
dall'utente, come risposta alla "risposta"...  hmmm, detto così può
sembrare un pò confuso, cerchiamo di spiegare meglio, con un esempio:
iniziamo subito con il tutorial.


Tutorial 1 - Un Breve Dialogo

Per entrare nel Dialog Editor, premete semplicemente il bottone
"Dialog Editor" presente nella Finestra Principale.

   - Premete il bottone "Nuova" per creare una nuova pagina di dialogo.
     Vi verrà mostrato un requester per l'inserimento del nome della
     pagina. Dal momento che questa pagina verrà utilizzata come
     punto di partenza, sarà meglio darle un nome significativo,
     scrivete quindi "Partenza_Dialogo".
     Adesso siete in grado di iniziare a scrivere le frasi vere e proprie.

   - Premete il bottone "Agg." in basso a sinistra, per aggiungere una
     nuova frase. La stringa "Nuova Frase" comparirà nel gadget chiamato,
     per l'appunto, "Frase:". Cancellate "Nuova Frase" ed inserite invece
     questo: "Ciao, come stai?"

   - Ripetete adesso il punto 2, inserendo però i messaggi:
     "Come va!" e "Adesso devo proprio andare".

   - Adesso dovremo creare una seconda pagina, premiamo "Nuova" e mettiamo
     come nome "Come_Stai", così ci ricorderemo che quello che
     immetteremo in questa pagina sarà in risposta a "Ciao, come stai?"
     della pagina precedente.

   - Nel gadget in alto, dove c'è scritto "Risposta:", scrivete "Bene!",
     questa è la risposta che il nostro interlocutore ci darà.
     Scrivere qualcosa in questo campo, non è strettamente necessario,
     ma è sempre meglio fare in modo che il nostro interlocutore dica
     qualcosa... altrimenti il nostro dialogo si potrebbe trasformare
     in un "monologo".
     L'unica situazione nella quale si può effettivamente omettere una
     stringa di risposta, è nella prima pagina del nostro dialogo,
     quando, cioe, "attachiamo bottone" con chi vogliamo parlare.

   - Ripetiamo il passo 2 e scriviamo solo una frase che dica
     "Ora vado, ciao".

   - Adesso dobbiamo preoccuparci di "agganciare" le due pagine di dialogo.
     Per farlo, torniamo alla prima pagina di dialogo. Permete il
     gadget "Seleziona": comparirà un Lister con i nomi delle pagine di
     dialogo, nel nostro caso, ci saranno due nomi: "Partenza_Dialogo" e
     "Come_Stai". Selezionate "Partenza_Dialogo".
     La finestra del Dialog Editor, mostrerà di nuovo la pagina che
     abbiamo editato in precedenza.

   - Adesso premete sulla frase "Ciao, Come Stai?", che comparirà nel
     gadget di stringa (se volete, potrete anche editarla e modificarla)
     e poi premete sul bottone chiamato "Salto:", apparirà lo stesso
     Lister che abbiamo appena incontrato. Questa volta, selezionate la
     frase "Come_Stai": il nome di questa pagina comparirà nel gadget
     di stringa "Salto:"
     Ecco fatto! Adesso, quando, durnate il gioco, l'utente selezionerà
     la frase "Ciao! Come Stai?", l'interlocutore risponderà "Bene!".
     E' stato facile, no?

   - Giusto per sport, agganciamo anche alla frase "Come Va?", la pagina
     "Come_Stai". Premete su "Come Va?", poi su "Salto:" e selezionate
     "Come_Stai".

NOTA: una stringa Senza salto significa FINE DEL DIALOGO. Quando l'utente
      seleziona una di queste frasi, il dialogo termina.
      Nel nostro esempio abbiamo ben due frasi di questo tipo: una è
     "Adesso devo proprio andare" nella prima pagina e "Ora vado, ciao"
      nella seconda pagina.

NOTA2: per convenzione, la frase che fa "uscire" dalla modalità di dialogo
       è l'ultima tra le scelte possibili. Dove potete, mantenete
       inalterata questa convenzione.



Descrizione generale.

Il Dialog Editor è utilizzato per creare dialoghi fra l'Omino ed un'altro
Oggetto sulla scena.  Come abbiamo avuto occasione di dire introducendo
questo editor, un dialogo è costituito da un numero di pagine agganciate
fra di loro; qualunque pagina può essere la prima pagina:  il nome della
prima pagina verrà passato come argomento all'istruzione ShowDialog nel
Doopsi Coder.  Tutte le altre pagine del dialogo seguono automaticamente
poiché sono agganciate assieme mediante il campo "Salto".

Descriviamo ora il contenuto di una pagina.  In ciascuna pagina vi è un
campo "Risposta" che contiene la frase che l'Oggetto dice quando è il suo
turno di parlare:  questo è il primo campo che il Player guarda quando
visualizza un dialogo.  Questo implica che se la prima pagina ha il campo
"Risposta" non vuoto, allora la conversazione viene iniziata dall'Oggetto.
Quando l'Oggetto ha finito di parlare (ovvero, quando l'utente, durante il
gioco, ha premuto il bottone del mouse per cancellare il testo che appare
sulla scena), tutte le frasi contenute nel grosso lister sotto il campo
"Risposta" vengono visualizzate nello spazio riservato alla console.  Il
Player attende che l'utente selezioni una frase e la visualizza sulla scena
(aspettando ancora che l'utente cancelli il testo prima di proseguire).
Poi il Player esamina il contenuto del campo "Salto":  se non è vuoto, il
Player cerca una pagina con il nome uguale alla stringa contenuta nel campo
"Salto".  Alla fine, se questa pagina è stata trovata il processo
ricomincia da capo:  viene visualizzata prima la risposta, poi le scelte al
di sotto di essa, e così via.  Un dialogo incontra la propria fine quando
il campo "Salto" della frase selezionata è vuoto oppure la pagina
agganciata non viene trovata.

Per costruire un dialogo dovete prima creare alcune pagine.  Il bottone
"Nuova" sulla destra crea una nuova pagina e chiede il nome da attribuire a
tale pagina:  questo nome è l'identificatore che Doopsi usa per indirizzare
la pagina, quindi dovete fare attenzione a non utilizzare due volte lo
stesso nome.  Per modificare la risposta, scrivetela semplicemente nel
gadget stringa "Risposta".  Per aggiungere una nuova frase dovete premere
il bottone "Agg.":  il testo "Nuova Frase" apparirà sia nel lister, sia nel
gadget stringa sotto di esso.  Ora potete modificare tale frase scrivendola
nel gadget stringa "Frase":  il nuovo testo rimpiazzerà quello vecchio nel
lister.  Nel campo "Salto" va inserito il nome della pagina a cui saltare
quando la frase corrente viene selezionata durante il gioco:  potete
modificare tale nome inserendolo a mano nel gadget stringa oppure premendo
il bottone "Salto"; quest'ultimo apre un lister con tutti i nomi delle
pagine create fino ad ora:  cliccate sul nome desiderato e poi sul gadget
"Va Bene".

Ora descriviamo i rimanenti gadget nella fila in basso.  Il bottone
"Memorizza" immagazzina il contenuto del campo "Frase" nel lister (è lo
stesso che premere il tasto Return nel campo "Frase").  Il gadget
"Seleziona" vi permette di muovervi attraverso le pagine:  quando lo
premete appare un lister con i nomi delle pagine create fino ad ora, e
potete selezionare quella da visualizzare.  Il gadget "Rimetti" annulla
l'ultima modifica apportata al campo "Frase".  Il bottone "Canc" rimuove la
frase correntemente selezionata.

I gadget nella colonna a destra hanno i seguenti significati.  Il gadget
"Nuova" crea una nuova pagina.  Il bottone "Salva" salva tutte le pagine
create sino ad ora, e il gadget "Carica" carica un insieme di pagine
salvate con il bottone precedente.  Il gadget "Nome Pag." vi permette di
cambiare il nome della pagina corrente.  Il bottone "Uccidi Pag." rimuove
solo la pagina corrente e il bottone "Uccidi Tutto" elimina tutte le
pagine create.



I Gadget:

Iniziamo con i gadget a destra sullo schermo:

Nuova             Crea una nuova pagina.

Carica            Carica un insieme di pagine.

Salva             Salva le pagine create.

Nome Pag.         Modifica il nome della pagina attuale.

Uccidi Pag.       Elimina la pagina corrente.

Uccidi Tutto      Elimina tutte le pagine create.


Ed ecco i bottoni in basso:

Agg.              Aggiunge una nuova frase.

Memorizza         Memorizza la pagina corrente.

Seleziona         Permette di selezionare una pagina di dialogo.

Rimetti           Rimette l'ultima frase modificata.

Canc              Cancella la frase attuale.


---------------------------------------------------------------------------


***********
Preferenze.
***********

Doopsi è un programma complesso e flessibile ed alcune delle sue
caratteristiche possono essere adattate alle esigenze del programmatore.
In Doopsi, le modifiche possono essere effettuate tramite la finestra di
Preferences, suddivisa in quattro sezioni, che esamineremo singolarmente.

Selezione dei Percorsi.

In questa sezione è possibile scegliere le directory contenenti tutti i
file di un determinato tipo.  Creando delle avventure complesse, è sempre
meglio suddividere grafica, suoni e tutto il resto in varie directory.  Con
questi percorsi, ogni volta che sarà necessario un file requester di un
determinato tipo (ad esempio per caricare un fondale) la directory verrà
automaticamente impostata a quella inserita nelle preferenze.  Nel caso non
si desideri utilizzare alcune delle directory di default, sarà sufficiente
inserire all'interno del campo una stringa vuota.

Il secondo gruppo di percorsi di default è dedicato al Player:  essi
servono al Player per trovare i file che sono indispensabili per iniziare
il gioco, vale a dire il file contenente la console (default:
"Doopsi:Data/panel.iff"), il file "player.dat" (default:
"Doopsi:Data/player.dat") ed infine (opzionale) il catalogo per un
linguaggio diverso dall'inglese (default:  "Doopsi:Data/player.catalog").
In questi string gadget occorre quindi inserire, oltre al percorso
completo, anche il nome dei file.  Questo permette, ad esempio, di
utilizzare una console diversa per ciascuna avventura.

L'ultimo string gadget, chiamato "Player", contiene il percorso completo ed
il nome del programma "DoopsiPlayer":  questo serve all'Editor per trovare
il Player quando viene premuto il bottone "Prova Gioco" nella Finestra
Principale.

A fianco del gadget di stringa contenente il path, c'è un piccolo gadget
con scritto "R" (ricerca), che aprirà un path requester con il quale sarà
possibile cercare la directory che desideriamo impostare come default.

Manipolazione dei Colori.

In questa sezione è possibile caricare, editare e salvare i colori
dell'interfaccia dell'editor di Doopsi.  Premendo "Carica" sarà possibile
caricare i primi quattro colori di una qualsiasi immagine IFF, con "Salva"
potremo salvare la palette e con "Edita" apparirà un Palette requester con
il quale sarà possibile modificare direttamente i colori.

Scelta dei nomi di Default.

Questa è forse la sezione più importante delle preferenze.  Come dovreste
sapere, Doopsi utilizza per il personaggio dell'avventura dei nomi di
default necessari perché il Player utilizzi le animazioni corrette quando
necessario.  Potete trovare la spiegazione di come questo meccanismo
funzioni nella sezione "Alcune note su come il Player trova l'Omino" posta
immediatamente dopo la sezione del manuale realtiva alla Finestra
Principale.  Seguono i nomi dei campi ed il loro significato:


NOME         VALORE DEF.  DESCRIZIONE

Root         Man          E' il nome "base" mediante il quale sono definiti
                          i nomi delle animazioni dell'Omino.

Left         L            Questi quattro valori determinano
Right        R            le animazioni del personaggio nelle varie
Up           U            direzioni. Ad es. "ManU" significa
Down         D            "animazione Omino che cammina verso l'alto"

Talk         Talk         Questa è una specie di "seconda root" ed
                          è il suffisso che viene aggiunto DIRETTAMENTE
                          alla Root vera e propria per definire le
                          animazioni del personaggio mentre parla.  A
                          questa root verrà poi aggiunto normalmente un
                          suffisso Left, Right, Up o Down.  Per es.  il
                          personaggio che parla a sinistra è definito così:
                          ManTalkL.

Questi nomi, essendo solo "interni" al Player, potevano anche rimanere
"rigidi" e non essere modificabili, ma abbiamo preferito permetterne la
modifica, per poter rendere tutto ancora più leggibile.  Infatti, potrete
modificare questi nomi, assegnando valori più significativi.  Facciamo un
esempio:

  Root = Uomo
  Talk = _che_parla
  L    = _a_sinistra
  R    = _a_destra

Il famigerato ManTalkL diventerà "Uomo_che_parla_a_sinistra", sicuramente
più elegante.  Ma attenzione, questo è solo un esempio:  i nomi interni
degli Oggetti in Doopsi possono essere di massimo 30 caratteri.

Scena di Partenza.

Con questa ultima parte della finestra di Preferences è possibile definire
il nome della prima scena che verrà mostrata all'avvio dell'avventura.

I bottoni USA/CARICA/SALVA/ANNULLA

I bottoni presenti in fondo alla finestra di Preferences permettono di
usare le preferenze appena inserite ("USA"), salvarne le preferenze attuali
("SALVA"), caricare una configurazione precedentemente salvata ("CARICA") e
di annullare i nuovi settaggi ("ANNULLA").


Nota:  le preferenze vengono SEMPRE salvate in un file completo di Doopsi,
per permettere la gestione di più avventure differenti contemporaneamente
con settaggi diversi.


---------------------------------------------------------------------------


********************************
Appendice A:  Istruzioni Doopsi.
********************************

Nella seguente lista oggetti e scene sono identificati utilizzando il loro
nome interno, quindi Oggetto rappresenta il nome interno dell'Oggetto
stesso, e così via.


AddStatus Oggetto, Valore

Aggiunge Valore al campo di stato dell'oggetto selezionato.  Il valore
totale dello stato di un oggetto è compreso fra -32767 e +32768.


ChangeDescription Oggetto, Testo

Cambia il nome dell'oggetto in Testo.  Questo nome è quello che appare
sulla linea di testo della console quando l'oggetto viene selezionato sulla
scena.


ChangeScene Scena

Se Scena è stata trovata questa istruzione esce dalla scena corrente e
visualizza la nuova scena.


ChangeShape Oggetto, Immagine

Cambia l'immagine attuale dell'Oggetto selezionato.  Se l'Oggetto è
visualizzato sulla scena la nuova immagine verrà disegnata e rimpiazzerà
quella vecchia.  Se l'oggetto è nell'inventario questo comando modificherà
l'immagine di inventario (e la ridisegnerà).  Infine, se l'Oggetto non è
visualizzato questa istruzione modificherà solo il valore dell'immagine
attuale dell'Oggetto stesso.  Questa istruzione non funziona con gli
AnimObject o con le Zone Vuote (per ovvi motivi) quando sono disegnate
sulla scena, ma le loro immagini di inventario potranno comunque essere
modificate.  Con ChangeShape l'immagine attuale dell'Oggetto è cancellata
perché la nuova immagine viene ridisegnata immediatamente sopra essa:
questo implica che le due immagini devono avere le medesime dimensioni.



ChangeShapeBG Oggetto, Immagine

Questo comando è simile a ChangeShape, ma prima di disegnare la nuova
immagine il Player cancella l'immagine attuale dell'Oggetto ridisegnando lo
sfondo.  Questo elimina la limitazione presente in ChangeShape che la nuova
immagine debba avere dimesioni uguali o maggiori di quella vecchia.

ChangeStatus Oggetto, Valore

Scrive Valore nel campo di stato dell'Oggetto selezionato.  Lo stato può
essere 0 o 1 per rappresentare una porta chiusa o aperta rispettivamente, e
così via...  Se l'oggetto è una moneta questo campo può essere usato per
memorizzare il numero di monete che l'Omino possiede.  Il valore che il
campo di stato di un oggetto può contenere va da -32767 a +32768.


Close Oggetto

Si veda l'istruzione Open.


ConsoleHide

Spegne la console.


ConsoleShow

Accende la console.


Drop Oggetto

Si veda l'istruzione Open.


Else

Else viene usato in un gruppo If:  se la condizione è falsa allora il
Player eseguirà tutte le istruzioni che seguono il comando Else fino al più
vicino EndIf (o fino alla fine del programma se quest'ultimo non è
presente).


EndIf

Questa istruzione termina un gruppo If.  Potete avere fino a 10 gruppi If
nidificati.


EraseInventory Oggetto

Rimuove l'Oggetto dalla lista dell'inventario e cancella la sua immagine di
inventario dalla console.


EraseObject Oggetto

Rimuove l'Oggetto dalla scena.  Questa istruzione non si applica agli
AnimObject:  in questo caso l'utente deve utilizzare StopAnim.


GetInventory Oggetto

Aggiunge l'Oggetto alla lista dell'inventario e disegna la sua immagine di
inventario attuale sulla console.  Questa istruzione fallisce se la lista
dell'inventario è piena, in quanto essa può contenere solo un numero
limitato di oggetti.


IfOnScene Oggetto

Restituisce Vero se l'Oggetto è disegnato sulla scena.


IfSceneIs Scena

Restituisce Vero se l'Omino è attualmente nella scena Scena.


IfStatus Oggetto, Stato

Restituisce Vero se il campo di stato dell'Oggetto selezionato è uguale a
Stato.


IfUsedWith Oggetto

Restituisce Vero se l'oggetto corrente è usato con Oggetto.  Questo
significa che avete prima selezionato il bottone Usa e cliccato una volta
su Oggetto e poi, dopo che il testo "Usa Oggetto con..." è apparso sulla
console, avete cliccato due volte sull'oggetto corrente:  questo attiva il
programma Doopsi relativo all'azione Usa dell'oggetto corrente dove
dovrebbe trovarsi questa istruzione.  Affinché cliccando su Oggetto appaia
la scritta "con..." ed il Player attenda la selezione di un altro oggetto è
necessario che Oggetto abbia UseWith come prima istruzione del programma
relativo all'azione Usa.


InvToScene Oggetto

Preleva l'Oggetto selezionato dall'inventario e lo disegna sulla scena alle
coordinate contenute in Oggetto:  tali coordinate sono inizializzate quando
l'Oggetto viene posizionato sulla scena mediante l'Editor.  Se l'oggetto è
un AnimObject l'animazione verrà automaticamente visualizzata.


InvToSpot Oggetto, Spot

Uguale a InvToScene, ma l'Oggetto verrà disegnato alle coordinate dello
Spot.


Look Oggetto

Si veda l'istruzione Open.


ManDirection Estensione

Forza l'Omino a girarsi nella direzione selezionata:  Estensione è una
delle quattro estensioni indicanti una direzione che l'utente può
modificare mediante l'editor di preferenze.


ManTalkColour Valore

Con questa istruzione l'utente sceglie il registro colore da usare per il
testo in tutte le successive istruzioni ShowText o ShowDialog quando
l'Omino parla.


MoveMan Spot

Questa istruzione permette all'utente di forzare l'Omino a muoversi verso
lo Spot desiderato sulla scena.


MoveObject Oggetto, Spot

Muove l'Oggetto dalla sua posizione attuale sulla scena alla posizione
specificata da Spot.  Durante il movimento un AnimObject verrà sostituito
all'immagine corrente dell'Oggetto se tale AnimObject è stato
precedentemente selezionato mediante l'istruzione SetMoveAnim.


MoveObjectOnPath Oggetto, Spot

Questo è simile a MoveObject con la differenza che l'Oggetto selezionato si
muoverà seguendo il percorso della scena corrente e si fermerà al nodo più
vicino allo Spot selezionato.  Un'altra leggera differenza è che si suppone
che l'hot-spot dell'oggetto (o, se presente, dell'animazione che lo
sostituisce) sia posizionato nell'angolo in basso a sinistra
dell'immagine.


MoveObjectToObject Oggetto1, Oggetto2

Questo è simile a MoveObject, e muove Oggetto1 alla posizione specificata
da Oggetto2.


MoveObjToObjOnPath Oggetto1, Oggetto2

Questo è simile a MoveObjectOnPath, e muove Oggetto1 alla posizione
specificata da Oggetto2.


MusicPause

Sospende momentaneamente la musica.  Per farla ripartire basta utilizzare
un'altra volta questo comando.


MusicPlay File

Suona il contenuto del File.  File deve essere un modulo tracker standard.


MusicStop

Interrompe la musica.


ObjTalkColour Valore

Questo è simile a ManTalkColour, ma vi permette di scegliere il registro
colore del testo dell'oggetto a cui l'Omino sta parlando durante una
istruzione ShowDialog.


Open  Oggetto
Close Oggetto
Look  Oggetto
Take  Oggetto
Drop  Oggetto
Push  Oggetto
Pull  Oggetto
Talk  Oggetto
Use   Oggetto

Queste istruzioni eseguono il codice Doopsi contenuto nella corrispondente
azione di Oggetto.  Esse sono gestite come sottoprogrammi, e potete
nidificare fino ad un massimo di 10 sottoprogrammi.


Pull Oggetto

Si veda l'istruzione Open.


Push Oggetto

Si veda l'istruzione Open.


PutObject Oggetto, Spot

Disegna l'Oggetto alla posizione dello Spot.  Oggetto può anche essere una
Zona Vuota.


SceneToInv Oggetto

Preleva l'Oggetto selezionato dalla scena e lo ripone nell'inventario.  Se
l'oggetto è un AnimObject l'animazione verrà automaticamente fermata.


SetManName Oggetto

Questa istruzione serve per cambiare le animazioni dell'Omino:  la radice
del nome (cioè dopo aver rimosso qualunque estensione) dell'Oggetto è
utilizzata per costruire i nomi dell'Omino fino a quando SetManName viene
chiamata nuovamente o è invocata da un nodo del percorso.


SetMoveAnim AnimObject

L'AnimObject selezionato verrà usato come animazione per la seguente
istruzione MoveObject o simili (MoveObjectOnPath, MoveObjectToObject,
MoveObjToObjOnPath).  Se il nome dell'AnimObject termina con una delle
quattro estensioni (indicanti le quattro direzioni) allora il Player è
autorizzato a scegliere la direzione opportuna prima di muovere l'oggetto:
se tale direzione non è fornita verrà utilizzata l'immagine corrente
dell'oggetto, e quindi la selezione dell'animazione sarà totalmente
ignorata.


SetTalkAnim AnimObject

Questa istruzione comunica al Player che, quando il prossimo ShowDialog
verrà eseguito, deve usare AnimObject per mostrare che l'oggetto
selezionato sta parlando.  Se l'utente termina il nome interno di
AnimObject mediante una delle quattro estensioni indicanti una direzione
(tali estensioni possono essere modificate usando l'editor di preferenze),
allora il Player rimuove questa estensione da tale nome interno e sceglie
la direzione appropriata (dipendente dalla posizione relativa dell'oggetto
rispetto all'Omino).  Poi aggancia l'estensione relativa alla direzione
scelta al nome interno di AnimObject e cerca l'oggetto risultante.  Se
questo viene trovato l'animazione corrispondente sarà visualizzata quando
l'oggetto parla.


ShowAnim AnimObject

Questa istruzione visualizza l'animazione contenuta in AnimObject.  Tale
animazione verrà posizionata alle coordinate interne di AnimObject:  queste
coordinate vengono inizializzate quando l'AnimObject è posizionato sulla
scena mediante l'Editor (e rimangono memorizzate anche se l'AnimObject
viene rimosso dalla scena in un secondo tempo).  Il numero di animazioni
che il Player può visualizzare contemporaneamente è limitato.


ShowAnimAtSpot AnimObject, Spot

Visualizza l'animazione contenuta in AnimObject alle coordinate di Spot.


ShowDialog Dialogo

Questo comando inizia una conversazione tra l'Omino e l'oggetto
selezionato.  Dialogo è la prima pagina della conversazione.  Se
l'animazione che mostra l'Omino che parla viene trovata essa sarà
visualizzata; potete scegliere un'animazione che mostra l'oggetto che parla
mediante SetTalkAnim.  I colori dei testi dell'Omino e dell'oggetto vengono
scelti mediante le istruzioni ManTalkColour e ObjTalkColour
rispettivamente.


ShowPicture File

Nasconde momentaneamente la scena e la console per visualizzare il
contenuto del File.  File deve essere un'immagine Iff ILBM.  Se l'immagine
è più grande dell'area dello schermo potete muoverla spostando il mouse
contro i bordi dello schermo.  Per ritornare allo stato precedente premere
il tasto sinistro del mouse.


ShowText Testo

Visualizza Testo.  La posizione e la suddivisione in linee del testo
verranno determinate automaticamente mediante la posizione dell'Omino sulla
scena e la larghezza della scena stessa.  La direzione dell'Omino determina
quale delle quattro animazioni verrà visualizzata, se presente, per far
parlare l'Omino; se l'animazione non è presente il Player non si lamenterà
e si limiterà a lasciare immutato l'Omino.  Il colore del testo può essere
cambiato utilizzando l'istruzione ManTalkColour.  Per cancellare il testo è
necessario premere il tasto sinistro del mouse.


SoundPlay File

Suona il contenuto del File.  File deve essere un campionamento Iff 8SVX
standard.


StopAnim AnimObject

Ferma l'animazione contenuta in AnimObject e la rimuove dalla scena.


Take Oggetto

Si veda l'istruzione Open.


Talk Oggetto

Si veda l'istruzione Open.


Use Oggetto

Si veda l'istruzione Open.


UseWith

Questa istruzione deve essere la prima nel programma dell'azione Usa di un
oggetto:  essa comunica al Player che l'oggetto corrente deve essere usato
insieme ad un altro oggetto; dunque il Player visualizza il testo "Usa
Oggetto con..." e aspetta che l'utente selezioni un altro oggetto.  Si veda
anche IfUsedWith.


---------------------------------------------------------------------------


*************************
Appendice B:  La console.
*************************

Lo schema della console incluso nel pacchetto di Doopsi mostra le diverse
zone controllate dal Player:  ci sono i nove bottoni delle azioni sulla
sinistra, due frecce verticali per far scorrere l'inventario e, fra queste,
un piccolo bottone usato per accedere all'interfaccia per il disco; la
parte destra è occupata dall'inventario e, ultimo ma non meno importante,
il rettangolo all'estremità superiore è la linea di testo dove appariranno
tutti i messaggi.  A proposito:  ciascun quadratino dell'inventario misura
32 * 32 pixel, quindi l'utente deve tener conto di queste dimensioni quando
progetta le immagini di inventario per i suoi oggetti.  Sotto la console,
sullo stesso schermo è rappresentata l'interfaccia per il disco:  l'area
più vasta sulla sinistra è quella in cui comparirà la lista dei file e
sotto di essa vi è lo spazio dove l'utente inserisce il percorso di ricerca
dei file stessi; poi vi sono due frecce verticali per scorrere la lista dei
file e cinque bottoni.

Lo schermo contenente la console e l'interfaccia disco deve essere in bassa
risoluzione non interlacciato e l'utente può disegnarci sopra tutto quello
che desidera, ma deve ricordare di rispettare le dimensioni delle zone
delimitate.  Si ricordi anche che i quadratini dell'inventario, la linea di
testo e l'area dedicata alla lista dei file vengono riempite dal Player con
il colore numero 0.  Un altro suggerimento:  tutte le immagini di
inventario devono avere la medesima palette, quella della console, in
quanto appariranno sulla console e quest'ultima rimane fissa per tutta la
durata del gioco; invece le altre immagini possono avere palette differenti
poiché è permesso cambiare i colori passando da una scena all'altra.


L'interfaccia del disco.

E' come tutti gli altri requester a cui siete abituati:  il percorso di
ricerca viene inserito nel gadget stringa situato nella parte bassa dello
schermo e i nomi dei file vengono elencati nell'area sopra di esso.  Per
caricare un file l'utente deve selezionarne il nome con il taso sinistro
del mouse e poi cliccare sul bottone Carica alla destra dello schermo.  Per
salvare un file l'utente deve selezionarne il nome e poi cliccare sul
bottone Salva:  apparirà un cursore per permettere all'utente di modificare
il nome del file; quando le eventuali modifiche sono state effettuate basta
premere Return per salvare.  Per salvare una nuova partita cliccate su
Salva come prima, senza selezionare alcun nome.

I nomi che compaiono nel lister ed il percorso di ricerca sono limitati ad
una lunghezza di 25 caratteri (penso sia abbastanza per la maggior parte
delle applicazioni).

I cinque bottoni sulla destra sono denominati, in ordine:  Carica, Salva,
Gioca, Workbench ed Esci.  I bottoni Carica e Salva sono già stati
descritti.  Il bottone Gioca permette di ritornare allo schermo della
console e di continuare il gioco.  Il bottone denominato Workbench attiva
il multitasking:  il Player scompare e l'utente può tornare alla partita
interrotta selezionando la voce Doopsi-GS nel menu Tools del Workbench.  Il
bottone Esci..., lascio a voi immaginare lo scopo di quello.


---------------------------------------------------------------------------


****************************
Appendice C:  Dentro Doopsi.
****************************

Nel seguito userò il termine Doopsi quando descriverò come funzionano
alcune parti comuni all'Editor ed al Player.


Struttura degli oggetti di Doopsi.

Per capire come Doopsi agisce e per ottenere il meglio da lui dovete
conoscere almeno l'essenziale della struttura degli oggetti Doopsi.

Iniziamo con una Scena:

   nome interno

   nome file dello sfondo

   lista di Oggetti agganciati (nomi interni)

Il nome interno è un nome privato che l'utente attribuisce alla Scena ed è
usato da Doopsi per riconoscere la Scena stessa.  Il nome dello sfondo è il
nome (completo di percorso) del file Iff contenente l'immagine da
visualizzare.  Segue poi una lista dei nomi interni degli Oggetti che
devono essere posizionati sulla Scena.

Veniamo ora ad un Oggetto. Vi sono tre tipi di oggetti, ma tutti
condividono la medesima struttura:

a) gli Oggetti tout-court sono semplicemente oggetti nel senso usuale del
termine e le loro immagini verranno disegnate sulla scena.

b) gli AnimObject contengono un'animazione che verrà visualizzata sulla
scena.

c) le Zone Vuote sono costituite da un rettangolo (che non sarà disegnato)
senza immagini.

Segue la struttura generale di un Oggetto:

   nome

   nome interno

   coordinata X

   coordinata Y

   Larghezza

   Altezza

   stato

   lista di immagini

   nove programmi di azione

Il nome è ciò che appare sulla linea di testo del Player quando il
puntatore è sull'oggetto.  Il nome interno è un nome privato (possibilmente
unico) che l'utente assegna all'oggetto ed è usato da Doopsi per
riconoscere l'oggetto stesso:  se l'utente utilizza più volte lo stesso
nome interno l'Editor non si lamenta, ma potreste ottenere risultati
imprevedibili (di solito Doopsi si ferma al primo oggetto che abbia il nome
interno richiesto).  Le coordinate X e Y specificano la posizione in cui
disegnare l'oggetto sullo schermo.  Larghezza ed Altezza sono le
dimensioni dell'oggetto.  Lo stato è un valore intero con nessun
significato particolare:  può essere usato per memorizzare lo stato
Acceso-Spento di una lampadina, o lo stato Aperto-Chiuso di una porta, o il
numero di monete che l'Omino possiede, e così via...  Segue poi una lista
di tutte le immagini (nome del file completo di percorso del file Iff
contenente l'immagine) che l'utente ha agganciato all'Oggetto.  Infine vi
sono nove programmi (contenenti del codice Doopsi), uno per ciascun bottone
della console del Player.

Un AnimObject differisce dalla precedente descrizione per il fatto che
possiede anche una stringa di interi che specifica la sequenza in cui le
immagini verranno visualizzate.  Larghezza ed Altezza conterranno la
massima larghezza ed altezza rispettivamente di tutte le immagini
selezionate per l'animazione.

Una Zona Vuota differisce per il fatto che non verrà disegnata sulla scena,
ma la sua posizione sarà comunque rivelata da Doopsi.  La lista di
immagini, però, non sarà necessariamente vuota in quanto l'utente potrebbe
aver bisogno, ad esempio, di riporre questo oggetto nell'inventario (e
quindi necessita di un'immagine di inventario), e così via.


---------------------------------------------------------------------------


**********
Il Player.
**********

La sequenza di avviamento.

Quando lanciate il Player, esso cerca prima di tutto il file principale di
Doopsi e, da questo momento in poi, tutte le azioni che intraprende sono
determinate dai dati che trova in tale file.  Dal file principale ricava il
percorso dove cercare la "console" (la parte bassa dello schermo dove
appaiono i bottoni e l'inventario), contenuta nel file "panel.iff", e il
file "player.dat".  Se non trova uno qualunque dei pezzi che ho appena
elencato si lamenta ed esce.

Supponendo che abbia svolto con successo i precedenti passi, il Player
cerca ora nel file Doopsi (il file principale che contiene tutta la
struttura del gioco) le animazioni del protagonista:  devono esserci
quattro animazioni, una per ciascuna direzione, con i nomi di default che
l'utente ha scelto.  Poiché questi dati sono vitali (come fate a giocare se
non vedete dove siete?) il Player si ferma ed esce se non ha trovato tutto
quello che stava cercando.  Questo significa che esso deve trovare prima di
tutto i quattro Oggetti che contengono tali animazioni e poi deve trovare
anche tutte le immagini necessarie.  A proposito, se l'utente fornisce
anche le animazioni per far parlare il protagonista esse verranno caricate:
in questo caso non è necessario fornire quattro animazioni se l'utente non
lo ritiene necessario poiché tali animazioni vengono utilizzate solo se
presenti.  Ma ricordate, se l'utente chiede al Player di usare
un'animazione questa animazione deve essere completa, vale a dire che il
Player deve essere in grado di trovare tutte le immagini necessarie.
Questa è una regola generale.

Ed ora veniamo al passo successivo:  fino ad ora il Player è stato in grado
di visualizzare la console, ma la metà superiore dello schermo è ancora
terribilmente nera.  Allora esso cerca nel file Doopsi la scena che avete
scelto come prima scena usando l'editor di Preferenze:  se l'utente si è
dimenticato di includere almeno una scena con tale nome allora il Player
non ha nient'altro da fare, perché non sa da quale scena iniziare il gioco,
ed esce ("ancora!" potreste esclamare, ma non penso che questo
comportamento sia dovuto a permalosità).  Ovviamente esce anche se la scena
è stata trovata ma non è presente il file Iff che contiene lo sfondo.

D'ora in poi il Player si lamenterà soltanto, senza uscire, se non troverà
qualcosa.  Errori comuni sono "Oggetto non trovato", se l'oggetto che
l'utente richiede non è nella lista, o "File non trovato" se non trova il
file contenente un'immagine o uno sfondo, ecc...  In questi casi non
succede nulla ed il gioco continua indisturbato.  I messaggi di errore
vengono visualizzati sulla console, nella stessa linea in cui appare la
scritta "Vai verso"; per eliminare il messaggio e ritornare al gioco
l'utente deve premere il tasto destro del mouse.

Se una scena è stata caricata con successo lo sfondo verrà visualizzato e
tutti gli oggetti in essa contenuti saranno disegnati sullo schermo:  gli
AnimObject sono automaticamente riconosciuti ed animati.  Supponendo che
sappiate già (dal manuale dell'Editor) cos'è un percorso Doopsi, vi dico
che il Player cerca prima un nodo nel percorso della scena corrente con il
nome uguale a quello della scena da cui proviene, poi, se questo fallisce,
cerca un nodo che ha lo stesso nome della scena corrente; infine disegna
l'Omino (che guarda l'utente) vicino al nodo trovato.

C'è anche qualcosa di leggermente tecnico che dovete sapere a proposito dei
nodi:  questi vi permettono di fornire una animazione diversa da quella di
default per l'Omino e di decidere dove cambiare scena; inoltre il percorso
della scena può essere influenzato da condizioni contenute nei suoi nodi.
Il Player legge il nome delle animazioni "custom", le condizioni ed i cambi
di scena da un nodo quando l'Omino ha i piedi sopra quel nodo:
l'animazione custom viene visualizzata solo quando l'Omino cammina dal nodo
attuale a quello successivo (così, se l'Omino si ferma sul nodo attuale voi
non potete vedere tale animazione e dovete fornire un fotogramma di riposo
all'animazione precedente), ma le condizioni e i cambi di scena sono letti
ed eseguiti immediatamente quando l'Omino arriva sul noto attuale.  Per
riassumere:  le animazioni custom di un nodo vengono eseguite quando
l'Omino si allontana da quel nodo, ma le condizioni e i cambi di scena
vengono eseguiti quando l'Omino arriva a quel nodo.

Alla fine il gioco inizia e voi diventate i protagonisti.


Errori.

Segue una breve descrizioni dei possibili errori.  I messaggi di errore
compaiono nella riga di testo e vengono cancellati premendo il tasto destro
del mouse.  Se l'errore è del tipo "... non trovato ..." il Player stampa
anche il nome dell'oggetto (o del file, ecc.) che non ha trovato.

Oggetto non trovato:    l'oggetto non è nella lista principale.
Scena non trovata:      la scena che avete richiesto non è nella lista.
File non trovato:       non penso ci sia bisogno di spiegazioni per
                        questo.
Spot non trovato:       l'utente ha richiesto uno spot inesistente.
Inventario pieno:       la lista dell'inventario è capiente ma limitata,
                        quindi se l'utente vi ripone troppi oggetti essa
                        può traboccare.
Niente spazio per l'animazione:  il numero di AnimObject che il Player può
                                 gestire contemporaneamente è limitato.
Dialogo non trovato:    l'utente ha richiesto una pagina di dialogo che non
                        esiste.
Directory non trovata:  questo messaggio compare nel file lister: l'utente
                        ha specificato un percorso inesistente.
Niente spazio per l'oggetto:  il numero di oggetti che una scena può
                              contenere è limitato.
Profondità eccessiva:   l'utente ha tentato di disegnare sulla scena un
                        oggetto con profondità maggiore di quella della
                        scena stessa.
EndIf senza If:         in un programma Doopsi vi è un'istruzione EndIf
                        senza il corrispondente comando If.
File Iff non valido:    dovete fornire un file Iff standard quando
                        esplicitamente richiesto, ad es.: nelle istruzioni
                        ShowPicture e SoundPlay.
Stack pieno:            si possono nidificare fino a 10 sottoprogrammi: se
                        ne aggiungete uno di troppo lo stack si esaurisce.


---------------------------------------------------------------------------


*****************
Limiti di Doopsi.
*****************

Qui sono riportate le limitazioni attuali di Doopsi:  le diciture
"Shareware" e "Special" indicano le limitazioni per le due versioni
dimostrative.


Editor:

Tipo                    numero Max
~~~~                    ~~~~~~~~~~
scene                   200         (Shareware: 3;  Special: 5)

oggetti                 500         (Shareware: 30; Special: 40)

pagine di dialogo       100         (Shareware: 5;  Special: 8)

linee per pagina di     12          (Shareware: 3;  Special: 4)
 dialogo

immagini per oggetto    15

oggetti sulla scena     20
 contemporaneamente

lunghezza nomi interni  30



Player: gli stessi dell'Editor più

Tipo                    numero Max
~~~~                    ~~~~~~~~~~
animobject sulla scena  10
 contemporaneamente

oggetti in inventario   500         (Shareware: 30; Special: 40)

sottoprogrammi          10
 nidificati

gruppi If nidificati    10